1 /* ImageMapster

     2    Version: 1.2.10 (2/25/2013)

     3 

     4 Copyright 2011-2012 James Treworgy

     5 

     6 http://www.outsharked.com/imagemapster

     7 https://github.com/jamietre/ImageMapster

     8 

     9 A jQuery plugin to enhance image maps.

    10 

    11 */

    12 

    13 ;

    14 

    15 /// LICENSE (MIT License)

    16 ///

    17 /// Permission is hereby granted, free of charge, to any person obtaining

    18 /// a copy of this software and associated documentation files (the

    19 /// "Software"), to deal in the Software without restriction, including

    20 /// without limitation the rights to use, copy, modify, merge, publish,

    21 /// distribute, sublicense, and/or sell copies of the Software, and to

    22 /// permit persons to whom the Software is furnished to do so, subject to

    23 /// the following conditions:

    24 ///

    25 /// The above copyright notice and this permission notice shall be

    26 /// included in all copies or substantial portions of the Software.

    27 ///

    28 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    29 /// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    30 /// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    31 /// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

    32 /// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

    33 /// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    34 /// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    35 ///

    36 /// January 19, 2011

    37 

    38 /** @license MIT License (c) copyright B Cavalier & J Hann */

    39 

    40 /**

    41 * when

    42 * A lightweight CommonJS Promises/A and when() implementation

    43 *

    44 * when is part of the cujo.js family of libraries (http://cujojs.com/)

    45 *

    46 * Licensed under the MIT License at:

    47 * http://www.opensource.org/licenses/mit-license.php

    48 *

    49 * @version 1.2.0

    50 */

    51 

    52 /*lint-ignore-start*/

    53 

    54 (function (define) {

    55     define(function () {

    56         var freeze, reduceArray, slice, undef;

    57 

    58         //

    59         // Public API

    60         //

    61 

    62         when.defer = defer;

    63         when.reject = reject;

    64         when.isPromise = isPromise;

    65 

    66         when.all = all;

    67         when.some = some;

    68         when.any = any;

    69 

    70         when.map = map;

    71         when.reduce = reduce;

    72 

    73         when.chain = chain;

    74 

    75         /** Object.freeze */

    76         freeze = Object.freeze || function (o) { return o; };

    77 

    78         /**

    79         * Trusted Promise constructor.  A Promise created from this constructor is

    80         * a trusted when.js promise.  Any other duck-typed promise is considered

    81         * untrusted.

    82         *

    83         * @constructor

    84         */

    85         function Promise() { }

    86 

    87         Promise.prototype = freeze({

    88             always: function (alwaysback, progback) {

    89                 return this.then(alwaysback, alwaysback, progback);

    90             },

    91 

    92             otherwise: function (errback) {

    93                 return this.then(undef, errback);

    94             }

    95         });

    96 

    97         /**

    98         * Create an already-resolved promise for the supplied value

    99         * @private

   100         *

   101         * @param value anything

   102         * @return {Promise}

   103         */

   104         function resolved(value) {

   105 

   106             var p = new Promise();

   107 

   108             p.then = function (callback) {

   109                 var nextValue;

   110                 try {

   111                     if (callback) nextValue = callback(value);

   112                     return promise(nextValue === undef ? value : nextValue);

   113                 } catch (e) {

   114                     return rejected(e);

   115                 }

   116             };

   117 

   118             return freeze(p);

   119         }

   120 

   121         /**

   122         * Create an already-rejected {@link Promise} with the supplied

   123         * rejection reason.

   124         * @private

   125         *

   126         * @param reason rejection reason

   127         * @return {Promise}

   128         */

   129         function rejected(reason) {

   130 

   131             var p = new Promise();

   132 

   133             p.then = function (callback, errback) {

   134                 var nextValue;

   135                 try {

   136                     if (errback) {

   137                         nextValue = errback(reason);

   138                         return promise(nextValue === undef ? reason : nextValue)

   139                     }

   140 

   141                     return rejected(reason);

   142 

   143                 } catch (e) {

   144                     return rejected(e);

   145                 }

   146             };

   147 

   148             return freeze(p);

   149         }

   150 

   151         /**

   152         * Returns a rejected promise for the supplied promiseOrValue. If

   153         * promiseOrValue is a value, it will be the rejection value of the

   154         * returned promise.  If promiseOrValue is a promise, its

   155         * completion value will be the rejected value of the returned promise

   156         *

   157         * @param promiseOrValue {*} the rejected value of the returned {@link Promise}

   158         *

   159         * @return {Promise} rejected {@link Promise}

   160         */

   161         function reject(promiseOrValue) {

   162             return when(promiseOrValue, function (value) {

   163                 return rejected(value);

   164             });

   165         }

   166 

   167         /**

   168         * Creates a new, CommonJS compliant, Deferred with fully isolated

   169         * resolver and promise parts, either or both of which may be given out

   170         * safely to consumers.

   171         * The Deferred itself has the full API: resolve, reject, progress, and

   172         * then. The resolver has resolve, reject, and progress.  The promise

   173         * only has then.

   174         *

   175         * @memberOf when

   176         * @function

   177         *

   178         * @returns {Deferred}

   179         */

   180         function defer() {

   181             var deferred, promise, listeners, progressHandlers, _then, _progress, complete;

   182 

   183             listeners = [];

   184             progressHandlers = [];

   185 

   186             /**

   187             * Pre-resolution then() that adds the supplied callback, errback, and progback

   188             * functions to the registered listeners

   189             *

   190             * @private

   191             *

   192             * @param [callback] {Function} resolution handler

   193             * @param [errback] {Function} rejection handler

   194             * @param [progback] {Function} progress handler

   195             *

   196             * @throws {Error} if any argument is not null, undefined, or a Function

   197             */

   198             _then = function unresolvedThen(callback, errback, progback) {

   199                 var deferred = defer();

   200 

   201                 listeners.push(function (promise) {

   202                     promise.then(callback, errback)

   203 					.then(deferred.resolve, deferred.reject, deferred.progress);

   204                 });

   205 

   206                 progback && progressHandlers.push(progback);

   207 

   208                 return deferred.promise;

   209             };

   210 

   211             /**

   212             * Registers a handler for this {@link Deferred}'s {@link Promise}.  Even though all arguments

   213             * are optional, each argument that *is* supplied must be null, undefined, or a Function.

   214             * Any other value will cause an Error to be thrown.

   215             *

   216             * @memberOf Promise

   217             *

   218             * @param [callback] {Function} resolution handler

   219             * @param [errback] {Function} rejection handler

   220             * @param [progback] {Function} progress handler

   221             *

   222             * @throws {Error} if any argument is not null, undefined, or a Function

   223             */

   224             function then(callback, errback, progback) {

   225                 return _then(callback, errback, progback);

   226             }

   227 

   228             /**

   229             * Resolves this {@link Deferred}'s {@link Promise} with val as the

   230             * resolution value.

   231             *

   232             * @memberOf Resolver

   233             *

   234             * @param val anything

   235             */

   236             function resolve(val) {

   237                 complete(resolved(val));

   238             }

   239 

   240             /**

   241             * Rejects this {@link Deferred}'s {@link Promise} with err as the

   242             * reason.

   243             *

   244             * @memberOf Resolver

   245             *

   246             * @param err anything

   247             */

   248             function reject(err) {

   249                 complete(rejected(err));

   250             }

   251 

   252             /**

   253             * @private

   254             * @param update

   255             */

   256             _progress = function (update) {

   257                 var progress, i = 0;

   258                 while (progress = progressHandlers[i++]) progress(update);

   259             };

   260 

   261             /**

   262             * Emits a progress update to all progress observers registered with

   263             * this {@link Deferred}'s {@link Promise}

   264             *

   265             * @memberOf Resolver

   266             *

   267             * @param update anything

   268             */

   269             function progress(update) {

   270                 _progress(update);

   271             }

   272 

   273             /**

   274             * Transition from pre-resolution state to post-resolution state, notifying

   275             * all listeners of the resolution or rejection

   276             *

   277             * @private

   278             *

   279             * @param completed {Promise} the completed value of this deferred

   280             */

   281             complete = function (completed) {

   282                 var listener, i = 0;

   283 

   284                 // Replace _then with one that directly notifies with the result.

   285                 _then = completed.then;

   286 

   287                 // Replace complete so that this Deferred can only be completed

   288                 // once. Also Replace _progress, so that subsequent attempts to issue

   289                 // progress throw.

   290                 complete = _progress = function alreadyCompleted() {

   291                     // TODO: Consider silently returning here so that parties who

   292                     // have a reference to the resolver cannot tell that the promise

   293                     // has been resolved using try/catch

   294                     throw new Error("already completed");

   295                 };

   296 

   297                 // Free progressHandlers array since we'll never issue progress events

   298                 // for this promise again now that it's completed

   299                 progressHandlers = undef;

   300 

   301                 // Notify listeners

   302                 // Traverse all listeners registered directly with this Deferred

   303 

   304                 while (listener = listeners[i++]) {

   305                     listener(completed);

   306                 }

   307 

   308                 listeners = [];

   309             };

   310 

   311             /**

   312             * The full Deferred object, with both {@link Promise} and {@link Resolver}

   313             * parts

   314             * @class Deferred

   315             * @name Deferred

   316             */

   317             deferred = {};

   318 

   319             // Promise and Resolver parts

   320             // Freeze Promise and Resolver APIs

   321 

   322             promise = new Promise();

   323             promise.then = deferred.then = then;

   324 

   325             /**

   326             * The {@link Promise} for this {@link Deferred}

   327             * @memberOf Deferred

   328             * @name promise

   329             * @type {Promise}

   330             */

   331             deferred.promise = freeze(promise);

   332 

   333             /**

   334             * The {@link Resolver} for this {@link Deferred}

   335             * @memberOf Deferred

   336             * @name resolver

   337             * @class Resolver

   338             */

   339             deferred.resolver = freeze({

   340                 resolve: (deferred.resolve = resolve),

   341                 reject: (deferred.reject = reject),

   342                 progress: (deferred.progress = progress)

   343             });

   344 

   345             return deferred;

   346         }

   347 

   348         /**

   349         * Determines if promiseOrValue is a promise or not.  Uses the feature

   350         * test from http://wiki.commonjs.org/wiki/Promises/A to determine if

   351         * promiseOrValue is a promise.

   352         *

   353         * @param promiseOrValue anything

   354         *

   355         * @returns {Boolean} true if promiseOrValue is a {@link Promise}

   356         */

   357         function isPromise(promiseOrValue) {

   358             return promiseOrValue && typeof promiseOrValue.then === 'function';

   359         }

   360 

   361         /**

   362         * Register an observer for a promise or immediate value.

   363         *

   364         * @function

   365         * @name when

   366         * @namespace

   367         *

   368         * @param promiseOrValue anything

   369         * @param {Function} [callback] callback to be called when promiseOrValue is

   370         *   successfully resolved.  If promiseOrValue is an immediate value, callback

   371         *   will be invoked immediately.

   372         * @param {Function} [errback] callback to be called when promiseOrValue is

   373         *   rejected.

   374         * @param {Function} [progressHandler] callback to be called when progress updates

   375         *   are issued for promiseOrValue.

   376         *

   377         * @returns {Promise} a new {@link Promise} that will complete with the return

   378         *   value of callback or errback or the completion value of promiseOrValue if

   379         *   callback and/or errback is not supplied.

   380         */

   381         function when(promiseOrValue, callback, errback, progressHandler) {

   382             // Get a promise for the input promiseOrValue

   383             // See promise()

   384             var trustedPromise = promise(promiseOrValue);

   385 

   386             // Register promise handlers

   387             return trustedPromise.then(callback, errback, progressHandler);

   388         }

   389 

   390         /**

   391         * Returns promiseOrValue if promiseOrValue is a {@link Promise}, a new Promise if

   392         * promiseOrValue is a foreign promise, or a new, already-resolved {@link Promise}

   393         * whose resolution value is promiseOrValue if promiseOrValue is an immediate value.

   394         *

   395         * Note that this function is not safe to export since it will return its

   396         * input when promiseOrValue is a {@link Promise}

   397         *

   398         * @private

   399         *

   400         * @param promiseOrValue anything

   401         *

   402         * @returns Guaranteed to return a trusted Promise.  If promiseOrValue is a when.js {@link Promise}

   403         *   returns promiseOrValue, otherwise, returns a new, already-resolved, when.js {@link Promise}

   404         *   whose resolution value is:

   405         *   * the resolution value of promiseOrValue if it's a foreign promise, or

   406         *   * promiseOrValue if it's a value

   407         */

   408         function promise(promiseOrValue) {

   409             var promise, deferred;

   410 

   411             if (promiseOrValue instanceof Promise) {

   412                 // It's a when.js promise, so we trust it

   413                 promise = promiseOrValue;

   414 

   415             } else {

   416                 // It's not a when.js promise.  Check to see if it's a foreign promise

   417                 // or a value.

   418 

   419                 deferred = defer();

   420                 if (isPromise(promiseOrValue)) {

   421                     // It's a compliant promise, but we don't know where it came from,

   422                     // so we don't trust its implementation entirely.  Introduce a trusted

   423                     // middleman when.js promise

   424 

   425                     // IMPORTANT: This is the only place when.js should ever call .then() on

   426                     // an untrusted promise.

   427                     promiseOrValue.then(deferred.resolve, deferred.reject, deferred.progress);

   428                     promise = deferred.promise;

   429 

   430                 } else {

   431                     // It's a value, not a promise.  Create an already-resolved promise

   432                     // for it.

   433                     deferred.resolve(promiseOrValue);

   434                     promise = deferred.promise;

   435                 }

   436             }

   437 

   438             return promise;

   439         }

   440 

   441         /**

   442         * Return a promise that will resolve when howMany of the supplied promisesOrValues

   443         * have resolved. The resolution value of the returned promise will be an array of

   444         * length howMany containing the resolutions values of the triggering promisesOrValues.

   445         *

   446         * @memberOf when

   447         *

   448         * @param promisesOrValues {Array} array of anything, may contain a mix

   449         *      of {@link Promise}s and values

   450         * @param howMany

   451         * @param [callback]

   452         * @param [errback]

   453         * @param [progressHandler]

   454         *

   455         * @returns {Promise}

   456         */

   457         function some(promisesOrValues, howMany, callback, errback, progressHandler) {

   458 

   459             checkCallbacks(2, arguments);

   460 

   461             return when(promisesOrValues, function (promisesOrValues) {

   462 

   463                 var toResolve, results, ret, deferred, resolver, rejecter, handleProgress, len, i;

   464 

   465                 len = promisesOrValues.length >>> 0;

   466 

   467                 toResolve = Math.max(0, Math.min(howMany, len));

   468                 results = [];

   469                 deferred = defer();

   470                 ret = when(deferred, callback, errback, progressHandler);

   471 

   472                 // Wrapper so that resolver can be replaced

   473                 function resolve(val) {

   474                     resolver(val);

   475                 }

   476 

   477                 // Wrapper so that rejecter can be replaced

   478                 function reject(err) {

   479                     rejecter(err);

   480                 }

   481 

   482                 // Wrapper so that progress can be replaced

   483                 function progress(update) {

   484                     handleProgress(update);

   485                 }

   486 

   487                 function complete() {

   488                     resolver = rejecter = handleProgress = noop;

   489                 }

   490 

   491                 // No items in the input, resolve immediately

   492                 if (!toResolve) {

   493                     deferred.resolve(results);

   494 

   495                 } else {

   496                     // Resolver for promises.  Captures the value and resolves

   497                     // the returned promise when toResolve reaches zero.

   498                     // Overwrites resolver var with a noop once promise has

   499                     // be resolved to cover case where n < promises.length

   500                     resolver = function (val) {

   501                         // This orders the values based on promise resolution order

   502                         // Another strategy would be to use the original position of

   503                         // the corresponding promise.

   504                         results.push(val);

   505 

   506                         if (! --toResolve) {

   507                             complete();

   508                             deferred.resolve(results);

   509                         }

   510                     };

   511 

   512                     // Rejecter for promises.  Rejects returned promise

   513                     // immediately, and overwrites rejecter var with a noop

   514                     // once promise to cover case where n < promises.length.

   515                     // TODO: Consider rejecting only when N (or promises.length - N?)

   516                     // promises have been rejected instead of only one?

   517                     rejecter = function (err) {

   518                         complete();

   519                         deferred.reject(err);

   520                     };

   521 

   522                     handleProgress = deferred.progress;

   523 

   524                     // TODO: Replace while with forEach

   525                     for (i = 0; i < len; ++i) {

   526                         if (i in promisesOrValues) {

   527                             when(promisesOrValues[i], resolve, reject, progress);

   528                         }

   529                     }

   530                 }

   531 

   532                 return ret;

   533             });

   534         }

   535 

   536         /**

   537         * Return a promise that will resolve only once all the supplied promisesOrValues

   538         * have resolved. The resolution value of the returned promise will be an array

   539         * containing the resolution values of each of the promisesOrValues.

   540         *

   541         * @memberOf when

   542         *

   543         * @param promisesOrValues {Array|Promise} array of anything, may contain a mix

   544         *      of {@link Promise}s and values

   545         * @param [callback] {Function}

   546         * @param [errback] {Function}

   547         * @param [progressHandler] {Function}

   548         *

   549         * @returns {Promise}

   550         */

   551         function all(promisesOrValues, callback, errback, progressHandler) {

   552 

   553             checkCallbacks(1, arguments);

   554 

   555             return when(promisesOrValues, function (promisesOrValues) {

   556                 return _reduce(promisesOrValues, reduceIntoArray, []);

   557             }).then(callback, errback, progressHandler);

   558         }

   559 

   560         function reduceIntoArray(current, val, i) {

   561             current[i] = val;

   562             return current;

   563         }

   564 

   565         /**

   566         * Return a promise that will resolve when any one of the supplied promisesOrValues

   567         * has resolved. The resolution value of the returned promise will be the resolution

   568         * value of the triggering promiseOrValue.

   569         *

   570         * @memberOf when

   571         *

   572         * @param promisesOrValues {Array|Promise} array of anything, may contain a mix

   573         *      of {@link Promise}s and values

   574         * @param [callback] {Function}

   575         * @param [errback] {Function}

   576         * @param [progressHandler] {Function}

   577         *

   578         * @returns {Promise}

   579         */

   580         function any(promisesOrValues, callback, errback, progressHandler) {

   581 

   582             function unwrapSingleResult(val) {

   583                 return callback ? callback(val[0]) : val[0];

   584             }

   585 

   586             return some(promisesOrValues, 1, unwrapSingleResult, errback, progressHandler);

   587         }

   588 

   589         /**

   590         * Traditional map function, similar to `Array.prototype.map()`, but allows

   591         * input to contain {@link Promise}s and/or values, and mapFunc may return

   592         * either a value or a {@link Promise}

   593         *

   594         * @memberOf when

   595         *

   596         * @param promise {Array|Promise} array of anything, may contain a mix

   597         *      of {@link Promise}s and values

   598         * @param mapFunc {Function} mapping function mapFunc(value) which may return

   599         *      either a {@link Promise} or value

   600         *

   601         * @returns {Promise} a {@link Promise} that will resolve to an array containing

   602         *      the mapped output values.

   603         */

   604         function map(promise, mapFunc) {

   605             return when(promise, function (array) {

   606                 return _map(array, mapFunc);

   607             });

   608         }

   609 

   610         /**

   611         * Private map helper to map an array of promises

   612         * @private

   613         *

   614         * @param promisesOrValues {Array}

   615         * @param mapFunc {Function}

   616         * @return {Promise}

   617         */

   618         function _map(promisesOrValues, mapFunc) {

   619 

   620             var results, len, i;

   621 

   622             // Since we know the resulting length, we can preallocate the results

   623             // array to avoid array expansions.

   624             len = promisesOrValues.length >>> 0;

   625             results = new Array(len);

   626 

   627             // Since mapFunc may be async, get all invocations of it into flight

   628             // asap, and then use reduce() to collect all the results

   629             for (i = 0; i < len; i++) {

   630                 if (i in promisesOrValues)

   631                     results[i] = when(promisesOrValues[i], mapFunc);

   632             }

   633 

   634             // Could use all() here, but that would result in another array

   635             // being allocated, i.e. map() would end up allocating 2 arrays

   636             // of size len instead of just 1.  Since all() uses reduce()

   637             // anyway, avoid the additional allocation by calling reduce

   638             // directly.

   639             return _reduce(results, reduceIntoArray, results);

   640         }

   641 

   642         /**

   643         * Traditional reduce function, similar to `Array.prototype.reduce()`, but

   644         * input may contain {@link Promise}s and/or values, and reduceFunc

   645         * may return either a value or a {@link Promise}, *and* initialValue may

   646         * be a {@link Promise} for the starting value.

   647         *

   648         * @memberOf when

   649         *

   650         * @param promise {Array|Promise} array of anything, may contain a mix

   651         *      of {@link Promise}s and values.  May also be a {@link Promise} for

   652         *      an array.

   653         * @param reduceFunc {Function} reduce function reduce(currentValue, nextValue, index, total),

   654         *      where total is the total number of items being reduced, and will be the same

   655         *      in each call to reduceFunc.

   656         * @param initialValue starting value, or a {@link Promise} for the starting value

   657         *

   658         * @returns {Promise} that will resolve to the final reduced value

   659         */

   660         function reduce(promise, reduceFunc, initialValue) {

   661             var args = slice.call(arguments, 1);

   662             return when(promise, function (array) {

   663                 return _reduce.apply(undef, [array].concat(args));

   664             });

   665         }

   666 

   667         /**

   668         * Private reduce to reduce an array of promises

   669         * @private

   670         *

   671         * @param promisesOrValues {Array}

   672         * @param reduceFunc {Function}

   673         * @param initialValue {*}

   674         * @return {Promise}

   675         */

   676         function _reduce(promisesOrValues, reduceFunc, initialValue) {

   677 

   678             var total, args;

   679 

   680             total = promisesOrValues.length;

   681 

   682             // Skip promisesOrValues, since it will be used as 'this' in the call

   683             // to the actual reduce engine below.

   684 

   685             // Wrap the supplied reduceFunc with one that handles promises and then

   686             // delegates to the supplied.

   687 

   688             args = [

   689 			function (current, val, i) {

   690 			    return when(current, function (c) {

   691 			        return when(val, function (value) {

   692 			            return reduceFunc(c, value, i, total);

   693 			        });

   694 			    });

   695 			}

   696 		];

   697 

   698             if (arguments.length > 2) args.push(initialValue);

   699 

   700             return reduceArray.apply(promisesOrValues, args);

   701         }

   702 

   703         /**

   704         * Ensure that resolution of promiseOrValue will complete resolver with the completion

   705         * value of promiseOrValue, or instead with resolveValue if it is provided.

   706         *

   707         * @memberOf when

   708         *

   709         * @param promiseOrValue

   710         * @param resolver {Resolver}

   711         * @param [resolveValue] anything

   712         *

   713         * @returns {Promise}

   714         */

   715         function chain(promiseOrValue, resolver, resolveValue) {

   716             var useResolveValue = arguments.length > 2;

   717 

   718             return when(promiseOrValue,

   719 			function (val) {

   720 			    if (useResolveValue) val = resolveValue;

   721 			    resolver.resolve(val);

   722 			    return val;

   723 			},

   724 			function (e) {

   725 			    resolver.reject(e);

   726 			    return rejected(e);

   727 			},

   728 			resolver.progress

   729 		);

   730         }

   731 

   732         //

   733         // Utility functions

   734         //

   735 

   736         /**

   737         * Helper that checks arrayOfCallbacks to ensure that each element is either

   738         * a function, or null or undefined.

   739         *

   740         * @private

   741         *

   742         * @param arrayOfCallbacks {Array} array to check

   743         * @throws {Error} if any element of arrayOfCallbacks is something other than

   744         * a Functions, null, or undefined.

   745         */

   746         function checkCallbacks(start, arrayOfCallbacks) {

   747             var arg, i = arrayOfCallbacks.length;

   748             while (i > start) {

   749                 arg = arrayOfCallbacks[--i];

   750                 if (arg != null && typeof arg != 'function') throw new Error('callback is not a function');

   751             }

   752         }

   753 

   754         /**

   755         * No-Op function used in method replacement

   756         * @private

   757         */

   758         function noop() { }

   759 

   760         slice = [].slice;

   761 

   762         // ES5 reduce implementation if native not available

   763         // See: http://es5.github.com/#x15.4.4.21 as there are many

   764         // specifics and edge cases.

   765         reduceArray = [].reduce ||

   766 		function (reduceFunc /*, initialValue */) {

   767 		    // ES5 dictates that reduce.length === 1

   768 

   769 		    // This implementation deviates from ES5 spec in the following ways:

   770 		    // 1. It does not check if reduceFunc is a Callable

   771 

   772 		    var arr, args, reduced, len, i;

   773 

   774 		    i = 0;

   775 		    arr = Object(this);

   776 		    len = arr.length >>> 0;

   777 		    args = arguments;

   778 

   779 		    // If no initialValue, use first item of array (we know length !== 0 here)

   780 		    // and adjust i to start at second item

   781 		    if (args.length <= 1) {

   782 		        // Skip to the first real element in the array

   783 		        for (; ; ) {

   784 		            if (i in arr) {

   785 		                reduced = arr[i++];

   786 		                break;

   787 		            }

   788 

   789 		            // If we reached the end of the array without finding any real

   790 		            // elements, it's a TypeError

   791 		            if (++i >= len) {

   792 		                throw new TypeError();

   793 		            }

   794 		        }

   795 		    } else {

   796 		        // If initialValue provided, use it

   797 		        reduced = args[1];

   798 		    }

   799 

   800 		    // Do the actual reduce

   801 		    for (; i < len; ++i) {

   802 		        // Skip holes

   803 		        if (i in arr)

   804 		            reduced = reduceFunc(reduced, arr[i], i, arr);

   805 		    }

   806 

   807 		    return reduced;

   808 		};

   809 

   810         return when;

   811     });

   812 })(typeof define == 'function'

   813 	? define

   814 	: function (factory) {

   815 	    typeof module != 'undefined'

   816 		? (module.exports = factory())

   817 		: (jQuery.mapster_when = factory());

   818 	}

   819 // Boilerplate for AMD, Node, and browser global

   820 );

   821 /*lint-ignore-end*/

   822 /* ImageMapster core */

   823 

   824 /*jslint laxbreak: true, evil: true, unparam: true */

   825 

   826 /*global jQuery: true, Zepto: true */

   827 

   828 

   829 (function ($) {

   830     // all public functions in $.mapster.impl are methods

   831     $.fn.mapster = function (method) {

   832         var m = $.mapster.impl;

   833         if ($.isFunction(m[method])) {

   834             return m[method].apply(this, Array.prototype.slice.call(arguments, 1));

   835         } else if (typeof method === 'object' || !method) {

   836             return m.bind.apply(this, arguments);

   837         } else {

   838             $.error('Method ' + method + ' does not exist on jQuery.mapster');

   839         }

   840     };

   841 

   842     $.mapster = {

   843         version: "1.2.10",

   844         render_defaults: {

   845             isSelectable: true,

   846             isDeselectable: true,

   847             fade: false,

   848             fadeDuration: 150,

   849             fill: true,

   850             fillColor: '000000',

   851             fillColorMask: 'FFFFFF',

   852             fillOpacity: 0.7,

   853             highlight: true,

   854             stroke: false,

   855             strokeColor: 'ff0000',

   856             strokeOpacity: 1,

   857             strokeWidth: 1,

   858             includeKeys: '',

   859             altImage: null,

   860             altImageId: null, // used internally            

   861             altImages: {} 

   862         },

   863         defaults: {

   864             clickNavigate: false,

   865             wrapClass: null,

   866             wrapCss: null,

   867             onGetList: null,

   868             sortList: false,

   869             listenToList: false,

   870             mapKey: '',

   871             mapValue: '',

   872             singleSelect: false,

   873             listKey: 'value',

   874             listSelectedAttribute: 'selected',

   875             listSelectedClass: null,

   876             onClick: null,

   877             onMouseover: null,

   878             onMouseout: null,

   879             mouseoutDelay: 0,

   880             onStateChange: null,

   881             boundList: null,

   882             onConfigured: null,

   883             configTimeout: 30000,

   884             noHrefIsMask: true,

   885             scaleMap: true,

   886             safeLoad: false,

   887             areas: []

   888         },

   889         shared_defaults: {

   890             render_highlight: { fade: true },

   891             render_select: { fade: false },

   892             staticState: null,

   893             selected: null

   894         },

   895         area_defaults:

   896         {

   897             includeKeys: '',

   898             isMask: false

   899         },

   900         canvas_style: {

   901             position: 'absolute',

   902             left: 0,

   903             top: 0,

   904             padding: 0,

   905             border: 0

   906         },

   907         hasCanvas: null,

   908         isTouch: null,

   909         map_cache: [],

   910         hooks: {},

   911         addHook: function(name,callback) {

   912             this.hooks[name]=(this.hooks[name]||[]).push(callback);

   913         },

   914         callHooks: function(name,context) {

   915             $.each(this.hooks[name]||[],function(i,e) {

   916                 e.apply(context);

   917             });

   918         },

   919         utils: {

   920             when: $.mapster_when,

   921             defer: $.mapster_when.defer,

   922 

   923             // extends the constructor, returns a new object prototype. Does not refer to the

   924             // original constructor so is protected if the original object is altered. This way you

   925             // can "extend" an object by replacing it with its subclass.

   926             subclass: function(BaseClass, constr) {

   927                 var Subclass=function() {

   928                     var me=this, 

   929                         args=Array.prototype.slice.call(arguments,0);

   930                     me.base = BaseClass.prototype;

   931                     me.base.init = function() {

   932                         BaseClass.prototype.constructor.apply(me,args);

   933                     };

   934                     constr.apply(me,args);

   935                 };

   936                 Subclass.prototype = new BaseClass();

   937                 Subclass.prototype.constructor=Subclass;

   938                 return Subclass;

   939             },

   940             asArray: function (obj) {

   941                 return obj.constructor === Array ?

   942                     obj : this.split(obj);

   943             },

   944             // clean split: no padding or empty elements

   945             split: function (text,cb) {

   946                 var i,el, arr = text.split(',');

   947                 for (i = 0; i < arr.length; i++) {

   948                     el = $.trim(arr[i]);

   949                     if (el==='') {

   950                         arr.splice(i,1);

   951                     } else {

   952                         arr[i] = cb ? cb(el):el;

   953                     }

   954                 }

   955                 return arr;

   956             },

   957             // similar to $.extend but does not add properties (only updates), unless the

   958             // first argument is an empty object, then all properties will be copied

   959             updateProps: function (_target, _template) {

   960                 var onlyProps,

   961                     target = _target || {},

   962                     template = $.isEmptyObject(target) ? _template : _target;

   963 

   964                 //if (template) {

   965                 onlyProps = [];

   966                 $.each(template, function (prop) {

   967                     onlyProps.push(prop);

   968                 });

   969                 //}

   970 

   971                 $.each(Array.prototype.slice.call(arguments, 1), function (i, src) {

   972                     $.each(src || {}, function (prop) {

   973                         if (!onlyProps || $.inArray(prop, onlyProps) >= 0) {

   974                             var p = src[prop];

   975 

   976                             if ($.isPlainObject(p)) {

   977                                 // not recursive - only copies 1 level of subobjects, and always merges

   978                                 target[prop] = $.extend(target[prop] || {}, p);

   979                             } else if (p && p.constructor === Array) {

   980                                 target[prop] = p.slice(0);

   981                             } else if (typeof p !== 'undefined') {

   982                                 target[prop] = src[prop];

   983                             }

   984 

   985                         }

   986                     });

   987                 });

   988                 return target;

   989             },

   990             isElement: function (o) {

   991                 return (typeof HTMLElement === "object" ? o instanceof HTMLElement :

   992                         o && typeof o === "object" && o.nodeType === 1 && typeof o.nodeName === "string");

   993             },

   994             // finds element of array or object with a property "prop" having value "val"

   995             // if prop is not defined, then just looks for property with value "val"

   996             indexOfProp: function (obj, prop, val) {

   997                 var result = obj.constructor === Array ? -1 : null;

   998                 $.each(obj, function (i, e) {

   999                     if (e && (prop ? e[prop] : e) === val) {

  1000                         result = i;

  1001                         return false;

  1002                     }

  1003                 });

  1004                 return result;

  1005             },

  1006             // returns "obj" if true or false, or "def" if not true/false

  1007             boolOrDefault: function (obj, def) {

  1008                 return this.isBool(obj) ?

  1009                         obj : def || false;

  1010             },

  1011             isBool: function (obj) {

  1012                 return typeof obj === "boolean";

  1013             },

  1014             isUndef: function(obj) {

  1015                 return typeof obj === "undefined";

  1016             },

  1017             // evaluates "obj", if function, calls it with args

  1018             // (todo - update this to handle variable lenght/more than one arg)

  1019             ifFunction: function (obj, that, args) {

  1020                 if ($.isFunction(obj)) {

  1021                     obj.call(that, args);

  1022                 }

  1023             },

  1024             size: function(image, raw) {

  1025                 var u=$.mapster.utils;

  1026                 return { 

  1027                     width: raw ? (image.width || image.naturalWidth) : u.imgWidth(image,true) ,

  1028                     height: raw ? (image.height || image.naturalHeight) : u.imgHeight(image,true),

  1029                     complete: function() { return !!this.height && !!this.width;}

  1030                 };

  1031             },

  1032 

  1033                 

  1034             /**

  1035              * Set the opacity of the element. This is an IE<8 specific function for handling VML.

  1036              * When using VML we must override the "setOpacity" utility function (monkey patch ourselves).

  1037              * jQuery does not deal with opacity correctly for VML elements. This deals with that.

  1038              * 

  1039              * @param {Element} el The DOM element

  1040              * @param {double} opacity A value between 0 and 1 inclusive.

  1041              */

  1042 

  1043             setOpacity: function (el, opacity) {

  1044                 if ($.mapster.hasCanvas()) {

  1045                     el.style.opacity = opacity;

  1046                 } else {

  1047                     $(el).each(function(i,e) {

  1048                         if (typeof e.opacity !=='undefined') {

  1049                            e.opacity=opacity;

  1050                         } else {

  1051                             $(e).css("opacity",opacity);

  1052                         }

  1053                     });

  1054                 }

  1055             },

  1056 

  1057 

  1058             // fade "el" from opacity "op" to "endOp" over a period of time "duration"

  1059             

  1060             fader: (function () {

  1061                 var elements = {},

  1062                         lastKey = 0,

  1063                         fade_func = function (el, op, endOp, duration) {

  1064                             var index, 

  1065                                 cbIntervals = duration/15,

  1066                                 obj, u = $.mapster.utils;

  1067 

  1068                             if (typeof el === 'number') {

  1069                                 obj = elements[el];

  1070                                 if (!obj) {

  1071                                     return;

  1072                                 }

  1073                             } else {

  1074                                 index = u.indexOfProp(elements, null, el);

  1075                                 if (index) {

  1076                                     delete elements[index];

  1077                                 }

  1078                                 elements[++lastKey] = obj = el;

  1079                                 el = lastKey;

  1080                             }

  1081 

  1082                             endOp = endOp || 1;

  1083 

  1084                             op = (op + (endOp / cbIntervals) > endOp - 0.01) ? endOp : op + (endOp / cbIntervals);

  1085 

  1086                             u.setOpacity(obj, op);

  1087                             if (op < endOp) {

  1088                                 setTimeout(function () {

  1089                                     fade_func(el, op, endOp, duration);

  1090                                 }, 15);

  1091                             }

  1092                         };

  1093                 return fade_func;

  1094             } ())

  1095         },

  1096         getBoundList: function (opts, key_list) {

  1097             if (!opts.boundList) {

  1098                 return null;

  1099             }

  1100             var index, key, result = $(), list = $.mapster.utils.split(key_list);

  1101             opts.boundList.each(function (i,e) {

  1102                 for (index = 0; index < list.length; index++) {

  1103                     key = list[index];

  1104                     if ($(e).is('[' + opts.listKey + '="' + key + '"]')) {

  1105                         result = result.add(e);

  1106                     }

  1107                 }

  1108             });

  1109             return result;

  1110         },

  1111         // Causes changes to the bound list based on the user action (select or deselect)

  1112         // area: the jQuery area object

  1113         // returns the matching elements from the bound list for the first area passed (normally only one should be passed, but

  1114         // a list can be passed

  1115         setBoundListProperties: function (opts, target, selected) {

  1116             target.each(function (i,e) {

  1117                 if (opts.listSelectedClass) {

  1118                     if (selected) {

  1119                         $(e).addClass(opts.listSelectedClass);

  1120                     } else {

  1121                         $(e).removeClass(opts.listSelectedClass);

  1122                     }

  1123                 }

  1124                 if (opts.listSelectedAttribute) {

  1125                     $(e).attr(opts.listSelectedAttribute, selected);

  1126                 }

  1127             });

  1128         },

  1129         getMapDataIndex: function (obj) {

  1130             var img, id;

  1131             switch (obj.tagName && obj.tagName.toLowerCase()) {

  1132                 case 'area':

  1133                     id = $(obj).parent().attr('name');

  1134                     img = $("img[usemap='#" + id + "']")[0];

  1135                     break;