text: /* ImageMapster
     Version: 1.2.10 (2/25/2013)
  
  Copyright 2011-2012 James Treworgy
  
  http://www.outsharked.com/imagemapster
  https://github.com/jamietre/ImageMapster
  
  A jQuery plugin to enhance image maps.
  
  */
  
  ;
  
  /// LICENSE (MIT License)
  ///
  /// Permission is hereby granted, free of charge, to any person obtaining
  /// a copy of this software and associated documentation files (the
  /// "Software"), to deal in the Software without restriction, including
  /// without limitation the rights to use, copy, modify, merge, publish,
  /// distribute, sublicense, and/or sell copies of the Software, and to
  /// permit persons to whom the Software is furnished to do so, subject to
  /// the following conditions:
  ///
  /// The above copyright notice and this permission notice shall be
  /// included in all copies or substantial portions of the Software.
  ///
  /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  /// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  /// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  /// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  /// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  /// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  /// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  ///
  /// January 19, 2011
  
  /** @license MIT License (c) copyright B Cavalier & J Hann */
  
  /**
  * when
  * A lightweight CommonJS Promises/A and when() implementation
  *
  * when is part of the cujo.js family of libraries (http://cujojs.com/)
  *
  * Licensed under the MIT License at:
  * http://www.opensource.org/licenses/mit-license.php
  *
  * @version 1.2.0
  */
  
  /*lint-ignore-start*/
  
  (function (define) {
      define(function () {
          var freeze, reduceArray, slice, undef;
  
          //
          // Public API
          //
  
          when.defer = defer;
          when.reject = reject;
          when.isPromise = isPromise;
  
          when.all = all;
          when.some = some;
          when.any = any;
  
          when.map = map;
          when.reduce = reduce;
  
          when.chain = chain;
  
          /** Object.freeze */
          freeze = Object.freeze || function (o) { return o; };
  
          /**
          * Trusted Promise constructor.  A Promise created from this constructor is
          * a trusted when.js promise.  Any other duck-typed promise is considered
          * untrusted.
          *
          * @constructor
          */
          function Promise() { }
  
          Promise.prototype = freeze({
              always: function (alwaysback, progback) {
                  return this.then(alwaysback, alwaysback, progback);
              },
  
              otherwise: function (errback) {
                  return this.then(undef, errback);
              }
          });
  
          /**
          * Create an already-resolved promise for the supplied value
          * @private
          *
          * @param value anything
          * @return {Promise}
          */
          function resolved(value) {
  
              var p = new Promise();
  
              p.then = function (callback) {
                  var nextValue;
                  try {
                      if (callback) nextValue = callback(value);
                      return promise(nextValue === undef ? value : nextValue);
                  } catch (e) {
                      return rejected(e);
                  }
              };
  
              return freeze(p);
          }
  
          /**
          * Create an already-rejected {@link Promise} with the supplied
          * rejection reason.
          * @private
          *
          * @param reason rejection reason
          * @return {Promise}
          */
          function rejected(reason) {
  
              var p = new Promise();
  
              p.then = function (callback, errback) {
                  var nextValue;
                  try {
                      if (errback) {
                          nextValue = errback(reason);
                          return promise(nextValue === undef ? reason : nextValue)
                      }
  
                      return rejected(reason);
  
                  } catch (e) {
                      return rejected(e);
                  }
              };
  
              return freeze(p);
          }
  
          /**
          * Returns a rejected promise for the supplied promiseOrValue. If
          * promiseOrValue is a value, it will be the rejection value of the
          * returned promise.  If promiseOrValue is a promise, its
          * completion value will be the rejected value of the returned promise
          *
          * @param promiseOrValue {*} the rejected value of the returned {@link Promise}
          *
          * @return {Promise} rejected {@link Promise}
          */
          function reject(promiseOrValue) {
              return when(promiseOrValue, function (value) {
                  return rejected(value);
              });
          }
  
          /**
          * Creates a new, CommonJS compliant, Deferred with fully isolated
          * resolver and promise parts, either or both of which may be given out
          * safely to consumers.
          * The Deferred itself has the full API: resolve, reject, progress, and
          * then. The resolver has resolve, reject, and progress.  The promise
          * only has then.
          *
          * @memberOf when
          * @function
          *
          * @returns {Deferred}
          */
          function defer() {
              var deferred, promise, listeners, progressHandlers, _then, _progress, complete;
  
              listeners = [];
              progressHandlers = [];
  
              /**
              * Pre-resolution then() that adds the supplied callback, errback, and progback
              * functions to the registered listeners
              *
              * @private
              *
              * @param [callback] {Function} resolution handler
              * @param [errback] {Function} rejection handler
              * @param [progback] {Function} progress handler
              *
              * @throws {Error} if any argument is not null, undefined, or a Function
              */
              _then = function unresolvedThen(callback, errback, progback) {
                  var deferred = defer();
  
                  listeners.push(function (promise) {
                      promise.then(callback, errback)
  					.then(deferred.resolve, deferred.reject, deferred.progress);
                  });
  
                  progback && progressHandlers.push(progback);
  
                  return deferred.promise;
              };
  
              /**
              * Registers a handler for this {@link Deferred}'s {@link Promise}.  Even though all arguments
              * are optional, each argument that *is* supplied must be null, undefined, or a Function.
              * Any other value will cause an Error to be thrown.
              *
              * @memberOf Promise
              *
              * @param [callback] {Function} resolution handler
              * @param [errback] {Function} rejection handler
              * @param [progback] {Function} progress handler
              *
              * @throws {Error} if any argument is not null, undefined, or a Function
              */
              function then(callback, errback, progback) {
                  return _then(callback, errback, progback);
              }
  
              /**
              * Resolves this {@link Deferred}'s {@link Promise} with val as the
              * resolution value.
              *
              * @memberOf Resolver
              *
              * @param val anything
              */
              function resolve(val) {
                  complete(resolved(val));
              }
  
              /**
              * Rejects this {@link Deferred}'s {@link Promise} with err as the
              * reason.
              *
              * @memberOf Resolver
              *
              * @param err anything
              */
              function reject(err) {
                  complete(rejected(err));
              }
  
              /**
              * @private
              * @param update
              */
              _progress = function (update) {
                  var progress, i = 0;
                  while (progress = progressHandlers[i++]) progress(update);
              };
  
              /**
              * Emits a progress update to all progress observers registered with
              * this {@link Deferred}'s {@link Promise}
              *
              * @memberOf Resolver
              *
              * @param update anything
              */
              function progress(update) {
                  _progress(update);
              }
  
              /**
              * Transition from pre-resolution state to post-resolution state, notifying
              * all listeners of the resolution or rejection
              *
              * @private
              *
              * @param completed {Promise} the completed value of this deferred
              */
              complete = function (completed) {
                  var listener, i = 0;
  
                  // Replace _then with one that directly notifies with the result.
                  _then = completed.then;
  
                  // Replace complete so that this Deferred can only be completed
                  // once. Also Replace _progress, so that subsequent attempts to issue
                  // progress throw.
                  complete = _progress = function alreadyCompleted() {
                      // TODO: Consider silently returning here so that parties who
                      // have a reference to the resolver cannot tell that the promise
                      // has been resolved using try/catch
                      throw new Error("already completed");
                  };
  
                  // Free progressHandlers array since we'll never issue progress events
                  // for this promise again now that it's completed
                  progressHandlers = undef;
  
                  // Notify listeners
                  // Traverse all listeners registered directly with this Deferred
  
                  while (listener = listeners[i++]) {
                      listener(completed);
                  }
  
                  listeners = [];
              };
  
              /**
              * The full Deferred object, with both {@link Promise} and {@link Resolver}
              * parts
              * @class Deferred
              * @name Deferred
              */
              deferred = {};
  
              // Promise and Resolver parts
              // Freeze Promise and Resolver APIs
  
              promise = new Promise();
              promise.then = deferred.then = then;
  
              /**
              * The {@link Promise} for this {@link Deferred}
              * @memberOf Deferred
              * @name promise
              * @type {Promise}
              */
              deferred.promise = freeze(promise);
  
              /**
              * The {@link Resolver} for this {@link Deferred}
              * @memberOf Deferred
              * @name resolver
              * @class Resolver
              */
              deferred.resolver = freeze({
                  resolve: (deferred.resolve = resolve),
                  reject: (deferred.reject = reject),
                  progress: (deferred.progress = progress)
              });
  
              return deferred;
          }
  
          /**
          * Determines if promiseOrValue is a promise or not.  Uses the feature
          * test from http://wiki.commonjs.org/wiki/Promises/A to determine if
          * promiseOrValue is a promise.
          *
          * @param promiseOrValue anything
          *
          * @returns {Boolean} true if promiseOrValue is a {@link Promise}
          */
          function isPromise(promiseOrValue) {
              return promiseOrValue && typeof promiseOrValue.then === 'function';
          }
  
          /**
          * Register an observer for a promise or immediate value.
          *
          * @function
          * @name when
          * @namespace
          *
          * @param promiseOrValue anything
          * @param {Function} [callback] callback to be called when promiseOrValue is
          *   successfully resolved.  If promiseOrValue is an immediate value, callback
          *   will be invoked immediately.
          * @param {Function} [errback] callback to be called when promiseOrValue is
          *   rejected.
          * @param {Function} [progressHandler] callback to be called when progress updates
          *   are issued for promiseOrValue.
          *
          * @returns {Promise} a new {@link Promise} that will complete with the return
          *   value of callback or errback or the completion value of promiseOrValue if
          *   callback and/or errback is not supplied.
          */
          function when(promiseOrValue, callback, errback, progressHandler) {
              // Get a promise for the input promiseOrValue
              // See promise()
              var trustedPromise = promise(promiseOrValue);
  
              // Register promise handlers
              return trustedPromise.then(callback, errback, progressHandler);
          }
  
          /**
          * Returns promiseOrValue if promiseOrValue is a {@link Promise}, a new Promise if
          * promiseOrValue is a foreign promise, or a new, already-resolved {@link Promise}
          * whose resolution value is promiseOrValue if promiseOrValue is an immediate value.
          *
          * Note that this function is not safe to export since it will return its
          * input when promiseOrValue is a {@link Promise}
          *
          * @private
          *
          * @param promiseOrValue anything
          *
          * @returns Guaranteed to return a trusted Promise.  If promiseOrValue is a when.js {@link Promise}
          *   returns promiseOrValue, otherwise, returns a new, already-resolved, when.js {@link Promise}
          *   whose resolution value is:
          *   * the resolution value of promiseOrValue if it's a foreign promise, or
          *   * promiseOrValue if it's a value
          */
          function promise(promiseOrValue) {
              var promise, deferred;
  
              if (promiseOrValue instanceof Promise) {
                  // It's a when.js promise, so we trust it
                  promise = promiseOrValue;
  
              } else {
                  // It's not a when.js promise.  Check to see if it's a foreign promise
                  // or a value.
  
                  deferred = defer();
                  if (isPromise(promiseOrValue)) {
                      // It's a compliant promise, but we don't know where it came from,
                      // so we don't trust its implementation entirely.  Introduce a trusted
                      // middleman when.js promise
  
                      // IMPORTANT: This is the only place when.js should ever call .then() on
                      // an untrusted promise.
                      promiseOrValue.then(deferred.resolve, deferred.reject, deferred.progress);
                      promise = deferred.promise;
  
                  } else {
                      // It's a value, not a promise.  Create an already-resolved promise
                      // for it.
                      deferred.resolve(promiseOrValue);
                      promise = deferred.promise;
                  }
              }
  
              return promise;
          }
  
          /**
          * Return a promise that will resolve when howMany of the supplied promisesOrValues
          * have resolved. The resolution value of the returned promise will be an array of
          * length howMany containing the resolutions values of the triggering promisesOrValues.
          *
          * @memberOf when
          *
          * @param promisesOrValues {Array} array of anything, may contain a mix
          *      of {@link Promise}s and values
          * @param howMany
          * @param [callback]
          * @param [errback]
          * @param [progressHandler]
          *
          * @returns {Promise}
          */
          function some(promisesOrValues, howMany, callback, errback, progressHandler) {
  
              checkCallbacks(2, arguments);
  
              return when(promisesOrValues, function (promisesOrValues) {
  
                  var toResolve, results, ret, deferred, resolver, rejecter, handleProgress, len, i;
  
                  len = promisesOrValues.length >>> 0;
  
                  toResolve = Math.max(0, Math.min(howMany, len));
                  results = [];
                  deferred = defer();
                  ret = when(deferred, callback, errback, progressHandler);
  
                  // Wrapper so that resolver can be replaced
                  function resolve(val) {
                      resolver(val);
                  }
  
                  // Wrapper so that rejecter can be replaced
                  function reject(err) {
                      rejecter(err);
                  }
  
                  // Wrapper so that progress can be replaced
                  function progress(update) {
                      handleProgress(update);
                  }
  
                  function complete() {
                      resolver = rejecter = handleProgress = noop;
                  }
  
                  // No items in the input, resolve immediately
                  if (!toResolve) {
                      deferred.resolve(results);
  
                  } else {
                      // Resolver for promises.  Captures the value and resolves
                      // the returned promise when toResolve reaches zero.
                      // Overwrites resolver var with a noop once promise has
                      // be resolved to cover case where n < promises.length
                      resolver = function (val) {
                          // This orders the values based on promise resolution order
                          // Another strategy would be to use the original position of
                          // the corresponding promise.
                          results.push(val);
  
                          if (! --toResolve) {
                              complete();
                              deferred.resolve(results);
                          }
                      };
  
                      // Rejecter for promises.  Rejects returned promise
                      // immediately, and overwrites rejecter var with a noop
                      // once promise to cover case where n < promises.length.
                      // TODO: Consider rejecting only when N (or promises.length - N?)
                      // promises have been rejected instead of only one?
                      rejecter = function (err) {
                          complete();
                          deferred.reject(err);
                      };
  
                      handleProgress = deferred.progress;
  
                      // TODO: Replace while with forEach
                      for (i = 0; i < len; ++i) {
                          if (i in promisesOrValues) {
                              when(promisesOrValues[i], resolve, reject, progress);
                          }
                      }
                  }
  
                  return ret;
              });
          }
  
          /**
          * Return a promise that will resolve only once all the supplied promisesOrValues
          * have resolved. The resolution value of the returned promise will be an array
          * containing the resolution values of each of the promisesOrValues.
          *
          * @memberOf when
          *
          * @param promisesOrValues {Array|Promise} array of anything, may contain a mix
          *      of {@link Promise}s and values
          * @param [callback] {Function}
          * @param [errback] {Function}
          * @param [progressHandler] {Function}
          *
          * @returns {Promise}
          */
          function all(promisesOrValues, callback, errback, progressHandler) {
  
              checkCallbacks(1, arguments);
  
              return when(promisesOrValues, function (promisesOrValues) {
                  return _reduce(promisesOrValues, reduceIntoArray, []);
              }).then(callback, errback, progressHandler);
          }
  
          function reduceIntoArray(current, val, i) {
              current[i] = val;
              return current;
          }
  
          /**
          * Return a promise that will resolve when any one of the supplied promisesOrValues
          * has resolved. The resolution value of the returned promise will be the resolution
          * value of the triggering promiseOrValue.
          *
          * @memberOf when
          *
          * @param promisesOrValues {Array|Promise} array of anything, may contain a mix
          *      of {@link Promise}s and values
          * @param [callback] {Function}
          * @param [errback] {Function}
          * @param [progressHandler] {Function}
          *
          * @returns {Promise}
          */
          function any(promisesOrValues, callback, errback, progressHandler) {
  
              function unwrapSingleResult(val) {
                  return callback ? callback(val[0]) : val[0];
              }
  
              return some(promisesOrValues, 1, unwrapSingleResult, errback, progressHandler);
          }
  
          /**
          * Traditional map function, similar to `Array.prototype.map()`, but allows
          * input to contain {@link Promise}s and/or values, and mapFunc may return
          * either a value or a {@link Promise}
          *
          * @memberOf when
          *
          * @param promise {Array|Promise} array of anything, may contain a mix
          *      of {@link Promise}s and values
          * @param mapFunc {Function} mapping function mapFunc(value) which may return
          *      either a {@link Promise} or value
          *
          * @returns {Promise} a {@link Promise} that will resolve to an array containing
          *      the mapped output values.
          */
          function map(promise, mapFunc) {
              return when(promise, function (array) {
                  return _map(array, mapFunc);
              });
          }
  
          /**
          * Private map helper to map an array of promises
          * @private
          *
          * @param promisesOrValues {Array}
          * @param mapFunc {Function}
          * @return {Promise}
          */
          function _map(promisesOrValues, mapFunc) {
  
              var results, len, i;
  
              // Since we know the resulting length, we can preallocate the results
              // array to avoid array expansions.
              len = promisesOrValues.length >>> 0;
              results = new Array(len);
  
              // Since mapFunc may be async, get all invocations of it into flight
              // asap, and then use reduce() to collect all the results
              for (i = 0; i < len; i++) {
                  if (i in promisesOrValues)
                      results[i] = when(promisesOrValues[i], mapFunc);
              }
  
              // Could use all() here, but that would result in another array
              // being allocated, i.e. map() would end up allocating 2 arrays
              // of size len instead of just 1.  Since all() uses reduce()
              // anyway, avoid the additional allocation by calling reduce
              // directly.
              return _reduce(results, reduceIntoArray, results);
          }
  
          /**
          * Traditional reduce function, similar to `Array.prototype.reduce()`, but
          * input may contain {@link Promise}s and/or values, and reduceFunc
          * may return either a value or a {@link Promise}, *and* initialValue may
          * be a {@link Promise} for the starting value.
          *
          * @memberOf when
          *
          * @param promise {Array|Promise} array of anything, may contain a mix
          *      of {@link Promise}s and values.  May also be a {@link Promise} for
          *      an array.
          * @param reduceFunc {Function} reduce function reduce(currentValue, nextValue, index, total),
          *      where total is the total number of items being reduced, and will be the same
          *      in each call to reduceFunc.
          * @param initialValue starting value, or a {@link Promise} for the starting value
          *
          * @returns {Promise} that will resolve to the final reduced value
          */
          function reduce(promise, reduceFunc, initialValue) {
              var args = slice.call(arguments, 1);
              return when(promise, function (array) {
                  return _reduce.apply(undef, [array].concat(args));
              });
          }
  
          /**
          * Private reduce to reduce an array of promises
          * @private
          *
          * @param promisesOrValues {Array}
          * @param reduceFunc {Function}
          * @param initialValue {*}
          * @return {Promise}
          */
          function _reduce(promisesOrValues, reduceFunc, initialValue) {
  
              var total, args;
  
              total = promisesOrValues.length;
  
              // Skip promisesOrValues, since it will be used as 'this' in the call
              // to the actual reduce engine below.
  
              // Wrap the supplied reduceFunc with one that handles promises and then
              // delegates to the supplied.
  
              args = [
  			function (current, val, i) {
  			    return when(current, function (c) {
  			        return when(val, function (value) {
  			            return reduceFunc(c, value, i, total);
  			        });
  			    });
  			}
  		];
  
              if (arguments.length > 2) args.push(initialValue);
  
              return reduceArray.apply(promisesOrValues, args);
          }
  
          /**
          * Ensure that resolution of promiseOrValue will complete resolver with the completion
          * value of promiseOrValue, or instead with resolveValue if it is provided.
          *
          * @memberOf when
          *
          * @param promiseOrValue
          * @param resolver {Resolver}
          * @param [resolveValue] anything
          *
          * @returns {Promise}
          */
          function chain(promiseOrValue, resolver, resolveValue) {
              var useResolveValue = arguments.length > 2;
  
              return when(promiseOrValue,
  			function (val) {
  			    if (useResolveValue) val = resolveValue;
  			    resolver.resolve(val);
  			    return val;
  			},
  			function (e) {
  			    resolver.reject(e);
  			    return rejected(e);
  			},
  			resolver.progress
  		);
          }
  
          //
          // Utility functions
          //
  
          /**
          * Helper that checks arrayOfCallbacks to ensure that each element is either
          * a function, or null or undefined.
          *
          * @private
          *
          * @param arrayOfCallbacks {Array} array to check
          * @throws {Error} if any element of arrayOfCallbacks is something other than
          * a Functions, null, or undefined.
          */
          function checkCallbacks(start, arrayOfCallbacks) {
              var arg, i = arrayOfCallbacks.length;
              while (i > start) {
                  arg = arrayOfCallbacks[--i];
                  if (arg != null && typeof arg != 'function') throw new Error('callback is not a function');
              }
          }
  
          /**
          * No-Op function used in method replacement
          * @private
          */
          function noop() { }
  
          slice = [].slice;
  
          // ES5 reduce implementation if native not available
          // See: http://es5.github.com/#x15.4.4.21 as there are many
          // specifics and edge cases.
          reduceArray = [].reduce ||
  		function (reduceFunc /*, initialValue */) {
  		    // ES5 dictates that reduce.length === 1
  
  		    // This implementation deviates from ES5 spec in the following ways:
  		    // 1. It does not check if reduceFunc is a Callable
  
  		    var arr, args, reduced, len, i;
  
  		    i = 0;
  		    arr = Object(this);
  		    len = arr.length >>> 0;
  		    args = arguments;
  
  		    // If no initialValue, use first item of array (we know length !== 0 here)
  		    // and adjust i to start at second item
  		    if (args.length <= 1) {
  		        // Skip to the first real element in the array
  		        for (; ; ) {
  		            if (i in arr) {
  		                reduced = arr[i++];
  		                break;
  		            }
  
  		            // If we reached the end of the array without finding any real
  		            // elements, it's a TypeError
  		            if (++i >= len) {
  		                throw new TypeError();
  		            }
  		        }
  		    } else {
  		        // If initialValue provided, use it
  		        reduced = args[1];
  		    }
  
  		    // Do the actual reduce
  		    for (; i < len; ++i) {
  		        // Skip holes
  		        if (i in arr)
  		            reduced = reduceFunc(reduced, arr[i], i, arr);
  		    }
  
  		    return reduced;
  		};
  
          return when;
      });
  })(typeof define == 'function'
  	? define
  	: function (factory) {
  	    typeof module != 'undefined'
  		? (module.exports = factory())
  		: (jQuery.mapster_when = factory());
  	}
  // Boilerplate for AMD, Node, and browser global
  );
  /*lint-ignore-end*/
  /* ImageMapster core */
  
  /*jslint laxbreak: true, evil: true, unparam: true */
  
  /*global jQuery: true, Zepto: true */
  
  
  (function ($) {
      // all public functions in $.mapster.impl are methods
      $.fn.mapster = function (method) {
          var m = $.mapster.impl;
          if ($.isFunction(m[method])) {
              return m[method].apply(this, Array.prototype.slice.call(arguments, 1));
          } else if (typeof method === 'object' || !method) {
              return m.bind.apply(this, arguments);
          } else {
              $.error('Method ' + method + ' does not exist on jQuery.mapster');
          }
      };
  
      $.mapster = {
          version: "1.2.10",
          render_defaults: {
              isSelectable: true,
              isDeselectable: true,
              fade: false,
              fadeDuration: 150,
              fill: true,
              fillColor: '000000',
              fillColorMask: 'FFFFFF',
              fillOpacity: 0.7,
              highlight: true,
              stroke: false,
              strokeColor: 'ff0000',
              strokeOpacity: 1,
              strokeWidth: 1,
              includeKeys: '',
              altImage: null,
              altImageId: null, // used internally            
              altImages: {},
  	    noFade: false, /*new: added by mimicat*/
  	    context: null /*new: added by mimicat*/
          },
          defaults: {
              clickNavigate: false,
              wrapClass: null,
              wrapCss: null,
              onGetList: null,
              sortList: false,
              listenToList: false,
              mapKey: '',
              mapValue: '',
              singleSelect: false,
              listKey: 'value',
              listSelectedAttribute: 'selected',
              listSelectedClass: null,
              onClick: null,
              onMouseover: null,
              onMouseout: null,
              mouseoutDelay: 0,
              onStateChange: null,
              boundList: null,
              onConfigured: null,
              configTimeout: 30000,
              noHrefIsMask: true,
              scaleMap: true,
              safeLoad: false,
              areas: [],
  	    
  	    permanentHover: false /*new: added by mimicat*/
          },
          shared_defaults: {
              render_highlight: { fade: true },
              render_select: { fade: false },
              staticState: null,
              selected: null
          },
          area_defaults:
          {
              includeKeys: '',
              isMask: false
          },
          canvas_style: {
              position: 'absolute',
              left: 0,
              top: 0,
              padding: 0,
              border: 0
          },
          hasCanvas: null,
          isTouch: null,
          map_cache: [],
          hooks: {},
          addHook: function(name,callback) {
              this.hooks[name]=(this.hooks[name]||[]).push(callback);
          },
          callHooks: function(name,context) {
              $.each(this.hooks[name]||[],function(i,e) {
                  e.apply(context);
              });
          },
          utils: {
              when: $.mapster_when,
              defer: $.mapster_when.defer,
  
              // extends the constructor, returns a new object prototype. Does not refer to the
              // original constructor so is protected if the original object is altered. This way you
              // can "extend" an object by replacing it with its subclass.
              subclass: function(BaseClass, constr) {
                  var Subclass=function() {
                      var me=this, 
                          args=Array.prototype.slice.call(arguments,0);
                      me.base = BaseClass.prototype;
                      me.base.init = function() {
                          BaseClass.prototype.constructor.apply(me,args);
                      };
                      constr.apply(me,args);
                  };
                  Subclass.prototype = new BaseClass();
                  Subclass.prototype.constructor=Subclass;
                  return Subclass;
              },
              asArray: function (obj) {
                  return obj.constructor === Array ?
                      obj : this.split(obj);
              },
              // clean split: no padding or empty elements
              split: function (text,cb) {
                  var i,el, arr = text.split(',');
                  for (i = 0; i < arr.length; i++) {
                      el = $.trim(arr[i]);
                      if (el==='') {
                          arr.splice(i,1);
                      } else {
                          arr[i] = cb ? cb(el):el;
                      }
                  }
                  return arr;
              },
              // similar to $.extend but does not add properties (only updates), unless the
              // first argument is an empty object, then all properties will be copied
              updateProps: function (_target, _template) {
                  var onlyProps,
                      target = _target || {},
                      template = $.isEmptyObject(target) ? _template : _target;
  
                  //if (template) {
                  onlyProps = [];
                  $.each(template, function (prop) {
                      onlyProps.push(prop);
                  });
                  //}
  
                  $.each(Array.prototype.slice.call(arguments, 1), function (i, src) {
                      $.each(src || {}, function (prop) {
                          if (!onlyProps || $.inArray(prop, onlyProps) >= 0) {
                              var p = src[prop];
  
                              if ($.isPlainObject(p)) {
                                  // not recursive - only copies 1 level of subobjects, and always merges
                                  target[prop] = $.extend(target[prop] || {}, p);
                              } else if (p && p.constructor === Array) {
                                  target[prop] = p.slice(0);
                              } else if (typeof p !== 'undefined') {
                                  target[prop] = src[prop];
                              }
  
                          }
                      });
                  });
                  return target;
              },
              isElement: function (o) {
                  return (typeof HTMLElement === "object" ? o instanceof HTMLElement :
                          o && typeof o === "object" && o.nodeType === 1 && typeof o.nodeName === "string");
              },
              // finds element of array or object with a property "prop" having value "val"
              // if prop is not defined, then just looks for property with value "val"
              indexOfProp: function (obj, prop, val) {
                  var result = obj.constructor === Array ? -1 : null;
                  $.each(obj, function (i, e) {
                      if (e && (prop ? e[prop] : e) === val) {
                          result = i;
                          return false;
                      }
                  });
                  return result;
              },
              // returns "obj" if true or false, or "def" if not true/false
              boolOrDefault: function (obj, def) {
                  return this.isBool(obj) ?
                          obj : def || false;
              },
              isBool: function (obj) {
                  return typeof obj === "boolean";
              },
              isUndef: function(obj) {
                  return typeof obj === "undefined";
              },
              // evaluates "obj", if function, calls it with args
              // (todo - update this to handle variable lenght/more than one arg)
              ifFunction: function (obj, that, args) {
                  if ($.isFunction(obj)) {
                      obj.call(that, args);
                  }
              },
              size: function(image, raw) {
                  var u=$.mapster.utils;
                  return { 
                      width: raw ? (image.width || image.naturalWidth) : u.imgWidth(image,true) ,
                      height: raw ? (image.height || image.naturalHeight) : u.imgHeight(image,true),
                      complete: function() { return !!this.height && !!this.width;}
                  };
              },
  
                  
              /**
               * Set the opacity of the element. This is an IE<8 specific function for handling VML.
               * When using VML we must override the "setOpacity" utility function (monkey patch ourselves).
               * jQuery does not deal with opacity correctly for VML elements. This deals with that.
               * 
               * @param {Element} el The DOM element
               * @param {double} opacity A value between 0 and 1 inclusive.
               */
  
              setOpacity: function (el, opacity) {
                  if ($.mapster.hasCanvas()) {
                      el.style.opacity = opacity;
                  } else {
                      $(el).each(function(i,e) {
                          if (typeof e.opacity !=='undefined') {
                             e.opacity=opacity;
                          } else {
                              $(e).css("opacity",opacity);
                          }
                      });
                  }
              },
  
  
              // fade "el" from opacity "op" to "endOp" over a period of time "duration"
              
              fader: (function () {
                  var elements = {},
                          lastKey = 0,
                          fade_func = function (el, op, endOp, duration) {
                              var index, 
                                  cbIntervals = duration/15,
                                  obj, u = $.mapster.utils;
  
                              if (typeof el === 'number') {
                                  obj = elements[el];
                                  if (!obj) {
                                      return;
                                  }
                              } else {
                                  index = u.indexOfProp(elements, null, el);
                                  if (index) {
                                      delete elements[index];
                                  }
                                  elements[++lastKey] = obj = el;
                                  el = lastKey;
                              }
  
                              endOp = endOp || 1;
  
                              op = (op + (endOp / cbIntervals) > endOp - 0.01) ? endOp : op + (endOp / cbIntervals);
  
                              u.setOpacity(obj, op);
                              if (op < endOp) {
                                  setTimeout(function () {
                                      fade_func(el, op, endOp, duration);
                                  }, 15);
                              }
                          };
                  return fade_func;
              } ())
          },
          getBoundList: function (opts, key_list) {
              if (!opts.boundList) {
                  return null;
              }
              var index, key, result = $(), list = $.mapster.utils.split(key_list);
              opts.boundList.each(function (i,e) {
                  for (index = 0; index < list.length; index++) {
                      key = list[index];
                      if ($(e).is('[' + opts.listKey + '="' + key + '"]')) {
                          result = result.add(e);
                      }
                  }
              });
              return result;
          },
          // Causes changes to the bound list based on the user action (select or deselect)
          // area: the jQuery area object
          // returns the matching elements from the bound list for the first area passed (normally only one should be passed, but
          // a list can be passed
          setBoundListProperties: function (opts, target, selected) {
              target.each(function (i,e) {
                  if (opts.listSelectedClass) {
                      if (selected) {
                          $(e).addClass(opts.listSelectedClass);
                      } else {
                          $(e).removeClass(opts.listSelectedClass);
                      }
                  }
                  if (opts.listSelectedAttribute) {
                      $(e).attr(opts.listSelectedAttribute, selected);
                  }
              });
          },
          getMapDataIndex: function (obj) {
              var img, id;
              switch (obj.tagName && obj.tagName.toLowerCase()) {
                  case 'area':
                      id = $(obj).parent().attr('name');
                      img = $("img[usemap='#" + id + "']")[0];
                      break;
                  case 'img':
                      img = obj;
                      break;
              }
              return img ?
                  this.utils.indexOfProp(this.map_cache, 'image', img) : -1;
          },
          getMapData: function (obj) {
              var index = this.getMapDataIndex(obj.length ? obj[0]:obj);
              if (index >= 0) {
                  return index >= 0 ? this.map_cache[index] : null;
              }
          },
          /**
           * Queue a command to be run after the active async operation has finished
           * @param  {MapData}  map_data    The target MapData object
           * @param  {jQuery}   that        jQuery object on which the command was invoked
           * @param  {string}   command     the ImageMapster method name
           * @param  {object[]} args        arguments passed to the method
           * @return {bool}                 true if the command was queued, false if not (e.g. there was no need to)
           */
          queueCommand: function (map_data, that, command, args) {
              if (!map_data) {
                  return false;
              }
              if (!map_data.complete || map_data.currentAction) {
                  map_data.commands.push(
                  {
                      that: that,
                      command: command,
                      args: args
                  });
                  return true;
              }
              return false;
          },
          unload: function () {
              this.impl.unload();
              this.utils = null;
              this.impl = null;
              $.fn.mapster = null;
              $.mapster = null;
              $('*').unbind();
          }
      };
  
      // Config for object prototypes
      // first: use only first object (for things that should not apply to lists)
      /// calls back one of two fuinctions, depending on whether an area was obtained.
      // opts: {
      //    name: 'method name',
      //    key: 'key,
      //    args: 'args'
      //
      //}
      // name: name of method (required)
      // args: arguments to re-call with
      // Iterates through all the objects passed, and determines whether it's an area or an image, and calls the appropriate
      // callback for each. If anything is returned from that callback, the process is stopped and that data return. Otherwise,
      // the object itself is returned.
      
      var m = $.mapster, 
          u = m.utils,
          ap = Array.prototype;
  
  
      // jQuery's width() and height() are broken on IE9 in some situations. This tries everything. 
      $.each(["width","height"],function(i,e) {
          var capProp = e.substr(0,1).toUpperCase() + e.substr(1);
          // when jqwidth parm is passed, it also checks the jQuery width()/height() property
          // the issue is that jQUery width() can report a valid size before the image is loaded in some browsers
          // without it, we can read zero even when image is loaded in other browsers if its not visible
          // we must still check because stuff like adblock can temporarily block it
          // what a goddamn headache
          u["img"+capProp]=function(img,jqwidth) {
                  return (jqwidth ? $(img)[e]() : 0) || 
                      img[e] || img["natural"+capProp] || img["client"+capProp] || img["offset"+capProp];
          };
       
      });    
  
      /**
       * The Method object encapsulates the process of testing an ImageMapster method to see if it's being
       * invoked on an image, or an area; then queues the command if the MapData is in an active state.
       * 
       * @param {[jQuery]}    that        The target of the invocation
       * @param {[function]}  func_map    The callback if the target is an imagemap
       * @param {[function]}  func_area   The callback if the target is an area
       * @param {[object]}    opt         Options: { key: a map key if passed explicitly
       *                                             name: the command name, if it can be queued,
       *                                             args: arguments to the method
       *                                            }
       */
      
      m.Method = function (that, func_map, func_area, opts) {
          var me = this;
          me.name = opts.name;
          me.output = that;
          me.input = that;
          me.first = opts.first || false;
          me.args = opts.args ? ap.slice.call(opts.args, 0) : [];
          me.key = opts.key;
          me.func_map = func_map;
          me.func_area = func_area;
          //$.extend(me, opts);
          me.name = opts.name;
          me.allowAsync = opts.allowAsync || false;
      };
      m.Method.prototype = {
          constructor: m.Method,
          go: function () {
              var i,  data, ar, len, result, src = this.input,
                      area_list = [],
                      me = this;
  
              len = src.length;
              for (i = 0; i < len; i++) {
                  data = $.mapster.getMapData(src[i]);
                  if (data) {
                      if (!me.allowAsync && m.queueCommand(data, me.input, me.name, me.args)) {
                          if (this.first) {
                              result = '';
                          }
                          continue;
                      }
                      
                      ar = data.getData(src[i].nodeName === 'AREA' ? src[i] : this.key);
                      if (ar) {
                          if ($.inArray(ar, area_list) < 0) {
                              area_list.push(ar);
                          }
                      } else {
                          result = this.func_map.apply(data, me.args);
                      }
                      if (this.first || typeof result !== 'undefined') {
                          break;
                      }
                  }
              }
              // if there were areas, call the area function for each unique group
              $(area_list).each(function (i,e) {
                  result = me.func_area.apply(e, me.args);
              });
  
              if (typeof result !== 'undefined') {
                  return result;
              } else {
                  return this.output;
              }
          }
      };
  
      $.mapster.impl = (function () {
          var me = {},
          addMap= function (map_data) {
              return m.map_cache.push(map_data) - 1;
          },
          removeMap = function (map_data) {
              m.map_cache.splice(map_data.index, 1);
              for (var i = m.map_cache.length - 1; i >= this.index; i--) {
                  m.map_cache[i].index--;
              }
          };
  
          
          /**
           * Test whether the browser supports VML. Credit: google.
           * http://stackoverflow.com/questions/654112/how-do-you-detect-support-for-vml-or-svg-in-a-browser
           * 
           * @return {bool} true if vml is supported, false if not
           */
          
          function hasVml() {
              var a = $('<div />').appendTo('body');
              a.html('<v:shape id="vml_flag1" adj="1" />');
              
              var b = a[0].firstChild;
              b.style.behavior = "url(#default#VML)";
              var has = b ? typeof b.adj === "object" : true;
              a.remove();
              return has;
          }
  
          /**
           * Return a reference to the IE namespaces object, if available, or an empty object otherwise
           * @return {obkect} The document.namespaces object.
           */
          function namespaces() {
              return typeof(document.namespaces)==='object' ?
                  document.namespaces :
                  null;
          }
  
          /**
           * Test for the presence of HTML5 Canvas support. This also checks to see if excanvas.js has been 
           * loaded and is faking it; if so, we assume that canvas is not supported.
           *
           * @return {bool} true if HTML5 canvas support, false if not
           */
          
          function hasCanvas() {
              var d = namespaces();
              // when g_vml_ is present, then we can be sure excanvas is active, meaning there's not a real canvas.
              
               return d && d.g_vml_ ? 
                  false :
                  $('<canvas />')[0].getContext ? 
                      true : 
                      false;
          }
  
          /**
           * Merge new area data into existing area options on a MapData object. Used for rebinding.
           * 
           * @param  {[MapData]} map_data     The MapData object
           * @param  {[object[]]} areas       areas array to merge
           */
          
          function merge_areas(map_data, areas) {
              var ar, index,
                  map_areas = map_data.options.areas;
  
              if (areas) {
                  $.each(areas, function (i, e) {
                      
                      // Issue #68 - ignore invalid data in areas array
                      
                      if (!e || !e.key) { 
                          return;
                      }
  
                      index = u.indexOfProp(map_areas, "key", e.key);
  
                      if (index >= 0) {
                          $.extend(map_areas[index], e);
                      }
                      else {
                          map_areas.push(e);
                      }
                      ar = map_data.getDataForKey(e.key);
                      if (ar) {
                          $.extend(ar.options, e);
                      }
                  });
              }
          }
          function merge_options(map_data, options) {
              var temp_opts = u.updateProps({}, options);
              delete temp_opts.areas;
  
              u.updateProps(map_data.options, temp_opts);
  
              merge_areas(map_data, options.areas);
              // refresh the area_option template
              u.updateProps(map_data.area_options, map_data.options);
          }
  
          // Most methods use the "Method" object which handles figuring out whether it's an image or area called and
          // parsing key parameters. The constructor wants:
          // this, the jQuery object
          // a function that is called when an image was passed (with a this context of the MapData)
          // a function that is called when an area was passed (with a this context of the AreaData)
          // options: first = true means only the first member of a jQuery object is handled
          //          key = the key parameters passed
          //          defaultReturn: a value to return other than the jQuery object (if its not chainable)
          //          args: the arguments
          // Returns a comma-separated list of user-selected areas. "staticState" areas are not considered selected for the purposes of this method.
          
          me.get = function (key) {
              var md = m.getMapData(this);
              if (!(md && md.complete)) {
                  throw("Can't access data until binding complete.");
              }
  
              return (new m.Method(this,
                  function () {
                      // map_data return
                      return this.getSelected();
                  },
                  function () {
                      return this.isSelected();
                  },
                  { name: 'get',
                      args: arguments,
                      key: key,
                      first: true,
                      allowAsync: true,
                      defaultReturn: ''
                  }
              )).go();
          };
          me.data = function (key) {
              return (new m.Method(this,
                  null,
                  function () {
                      return this;
                  },
                  { name: 'data',
                      args: arguments,
                      key: key
                  }
              )).go();
          };
  
  
          // Set or return highlight state.
          //  $(img).mapster('highlight') -- return highlighted area key, or null if none
          //  $(area).mapster('highlight') -- highlight an area
          //  $(img).mapster('highlight','area_key') -- highlight an area
          //  $(img).mapster('highlight',false) -- remove highlight
          me.highlight = function (key) {
              return (new m.Method(this,
                  function () {
                      if (key === false) {
                          this.ensureNoHighlight();
                      } else {
                          var id = this.highlightId;
                          return id >= 0 ? this.data[id].key : null;
                      }
                  },
                  function () {
                      this.highlight();
                  },
                  { name: 'highlight',
                      args: arguments,
                      key: key,
                      first: true
                  }
              )).go();
          };
          // Return the primary keys for an area or group key.
          // $(area).mapster('key')
          // includes all keys (not just primary keys)
          // $(area).mapster('key',true)
          // $(img).mapster('key','group-key')
  
          // $(img).mapster('key','group-key', true)
          me.keys = function(key,all) {
              var keyList=[], 
                  md = m.getMapData(this);
  
              if (!(md && md.complete)) {
                  throw("Can't access data until binding complete.");
              }
  
  
              function addUniqueKeys(ad) {
                  var areas,keys=[];
                  if (!all) {
                      keys.push(ad.key);
                  } else {
                      areas=ad.areas();
                      $.each(areas,function(i,e) {
                          keys=keys.concat(e.keys);
                      });
                  }
                  $.each(keys,function(i,e) {
                      if ($.inArray(e,keyList)<0) {
                          keyList.push(e);                         
                      }
                  });
              }
  
              if (!(md  && md.complete)) {
                  return '';
              }
              if (typeof key === 'string') {
                  if (all) {
                      addUniqueKeys(md.getDataForKey(key));
                  } else {
                      keyList=[md.getKeysForGroup(key)];
                  }
              } else {
                  all = key;
                  this.each(function(i,e) {
                      if (e.nodeName==='AREA') {
                          addUniqueKeys(md.getDataForArea(e));
                      }
                  });
              }
              return keyList.join(',');
          
  
          };
          me.select = function () {
              me.set.call(this, true);
          };
          me.deselect = function () {
              me.set.call(this, false);
          };
          
          /**
           * Select or unselect areas. Areas can be identified by a single string key, a comma-separated list of keys, 
           * or an array of strings.
           * 
           * 
           * @param {boolean} selected Determines whether areas are selected or deselected
           * @param {string|string[]} key A string, comma-separated string, or array of strings indicating 
           *                              the areas to select or deselect
           * @param {object} options Rendering options to apply when selecting an area
           */ 
  
          me.set = function (selected, key, options) {
              var lastMap, map_data, opts=options,
                  key_list, area_list; // array of unique areas passed
  
              function setSelection(ar) {
                  if (ar) {
                      switch (selected) {
                          case true:
                              ar.select(opts); break;
                          case false:
                              ar.deselect(true); break;
                          default:
                              ar.toggle(opts); break;
                      }
                  }
              }
              function addArea(ar) {
                 if (ar && $.inArray(ar, area_list) < 0) {
                      area_list.push(ar);
                      key_list+=(key_list===''?'':',')+ar.key;
                  }
              }
              // Clean up after a group that applied to the same map
              function finishSetForMap(map_data) {
                  $.each(area_list, function (i, el) {
                      setSelection(el);
                  });
                  if (!selected) {
                      map_data.removeSelectionFinish();
                  }
                  if (map_data.options.boundList) {
                      m.setBoundListProperties(map_data.options, m.getBoundList(map_data.options, key_list), selected);
                  }            
              }
  
              this.filter('img,area').each(function (i,e) {
                  var keys;
                  map_data = m.getMapData(e);
  
                  if (map_data !== lastMap) {
                      if (lastMap) {
                         finishSetForMap(lastMap);
                      }
  
                      area_list = [];
                      key_list='';
                  }
                  
                 if (map_data) {
                      
                      keys = '';
                      if (e.nodeName.toUpperCase()==='IMG') {
                          if (!m.queueCommand(map_data, $(e), 'set', [selected, key, opts])) {
                              if (key instanceof Array) {
                                  if (key.length) {
                                      keys = key.join(",");
                                  }
                              }
                              else {
                                  keys = key;
                              }
  
                              if (keys) {
                                  $.each(u.split(keys), function (i,key) {
                                      addArea(map_data.getDataForKey(key.toString()));
                                      lastMap = map_data;
                                  });
                              }
                          }
                      } else {
                          opts=key;
                          if (!m.queueCommand(map_data, $(e), 'set', [selected, opts])) {
                              addArea(map_data.getDataForArea(e));
                              lastMap = map_data;
                          }
                      
                      }
                  }
              });
              
              if (map_data) {
                 finishSetForMap(map_data);
              }
  
             
              return this;
          };
          me.unbind = function (preserveState) {
              return (new m.Method(this,
                  function () {
                      this.clearEvents();
                      this.clearMapData(preserveState);
                      removeMap(this);
                  },
                  null,
                  { name: 'unbind',
                      args: arguments
                  }
              )).go();
          };
  
  
          // refresh options and update selection information.
          me.rebind = function (options) {
              return (new m.Method(this,
                  function () {
                      var me=this;
  
                      me.complete=false;
                      me.configureOptions(options);
                      me.bindImages().then(function() {
                          me.buildDataset(true);
                          me.complete=true;
                      });
                      //this.redrawSelections();
                  },
                  null,
                  {
                      name: 'rebind',
                      args: arguments
                  }
              )).go();
          };
          // get options. nothing or false to get, or "true" to get effective options (versus passed options)
          me.get_options = function (key, effective) {
              var eff = u.isBool(key) ? key : effective; // allow 2nd parm as "effective" when no key
              return (new m.Method(this,
                  function () {
                      var opts = $.extend({}, this.options);
                      if (eff) {
                          opts.render_select = u.updateProps(
                              {},
                              m.render_defaults,
                              opts,
                              opts.render_select);
  
                          opts.render_highlight = u.updateProps(
                              {},
                              m.render_defaults,
                              opts,
                              opts.render_highlight);
                      }
                      return opts;
                  },
                  function () {
                      return eff ? this.effectiveOptions() : this.options;
                  },
                  {
                      name: 'get_options',
                      args: arguments,
                      first: true,
                      allowAsync: true,
                      key: key
                  }
              )).go();
          };
  
          // set options - pass an object with options to set,
          me.set_options = function (options) {
              return (new m.Method(this,
                  function () {
                      merge_options(this, options);
                  },
                  null,
                  {
                      name: 'set_options',
                      args: arguments
                  }
              )).go();
          };
          me.unload = function () {
              var i;
              for (i = m.map_cache.length - 1; i >= 0; i--) {
                  if (m.map_cache[i]) {
                      me.unbind.call($(m.map_cache[i].image));
                  }
              }
              me.graphics = null;
          };
  
          me.snapshot = function () {
              return (new m.Method(this,
                  function () {
                      $.each(this.data, function (i, e) {
                          e.selected = false;
                      });
  
                      this.base_canvas = this.graphics.createVisibleCanvas(this);
                      $(this.image).before(this.base_canvas);
                  },
                  null,
                  { name: 'snapshot' }
              )).go();
          };
          
          // do not queue this function
          
          me.state = function () {
              var md, result = null;
              $(this).each(function (i,e) {
                  if (e.nodeName === 'IMG') {
                      md = m.getMapData(e);
                      if (md) {
                          result = md.state();
                      }
                      return false;
                  }
              });
              return result;
          };
  
          me.bind = function (options) {
  
              return this.each(function (i,e) {
                  var img, map, usemap, md;
  
                  // save ref to this image even if we can't access it yet. commands will be queued
                  img = $(e);
  
                  md = m.getMapData(e);
  
                  // if already bound completely, do a total rebind
                  
                  if (md) {
                      me.unbind.apply(img);
                      if (!md.complete) {
                          // will be queued
                          img.bind();
                          return true;
                      }
                      md = null;
                  }
  
                  // ensure it's a valid image
                  // jQuery bug with Opera, results in full-url#usemap being returned from jQuery's attr.
                  // So use raw getAttribute instead.
                  
                  usemap = this.getAttribute('usemap');
                  map = usemap && $('map[name="' + usemap.substr(1) + '"]');
                  if (!(img.is('img') && usemap && map.size() > 0)) {
                      return true;
                  }
  
                  // sorry - your image must have border:0, things are too unpredictable otherwise.
                  img.css('border', 0);
  
                  if (!md) {
                      md = new m.MapData(this, options);
  
                      md.index = addMap(md);
                      md.map = map;
                      md.bindImages().then(function() {
                          md.initialize();
                      });
                  }
              });
          };
  
          me.init = function (useCanvas) {
              var style, shapes;
  
              // for testing/debugging, use of canvas can be forced by initializing 
              // manually with "true" or "false". But generally we test for it.
              
              m.hasCanvas = function() {
                  if (!u.isBool(m.hasCanvas.value)) {
                      m.hasCanvas.value = u.isBool(useCanvas) ?
                          useCanvas : 
                          hasCanvas();
                  }
                  return m.hasCanvas.value;
              };
              m.hasVml = function() {
                  if (!u.isBool(m.hasVml.value)) {
                      // initialize VML the first time we detect its presence.
                      var d = namespaces();
  
                      if (d && !d.v) {
                          d.add("v", "urn:schemas-microsoft-com:vml");
                          style = document.createStyleSheet();
                          shapes = ['shape', 'rect', 'oval', 'circ', 'fill', 'stroke', 'imagedata', 'group', 'textbox'];
                          $.each(shapes,
                          function (i, el) {
                              style.addRule('v\\:' + el, "behavior: url(#default#VML); antialias:true");
                          });
                      }
                      m.hasVml.value = hasVml();
                  }
  
                  return m.hasVml.value;
              };
  
              m.isTouch = !!document.documentElement.ontouchstart;
  
              $.extend(m.defaults, m.render_defaults,m.shared_defaults);
              $.extend(m.area_defaults, m.render_defaults,m.shared_defaults);
              
          };
          me.test = function (obj) {
              return eval(obj);
          };
          return me;
      } ());
      
      $.mapster.impl.init();
      
      
  } (jQuery));
  /* graphics.js
     Graphics object handles all rendering.
  */
  (function ($) {
      var p, m=$.mapster,
          u=m.utils,
          canvasMethods,
          vmlMethods;
      
      /**
       * Implemenation to add each area in an AreaData object to the canvas
       * @param {Graphics} graphics The target graphics object
       * @param {AreaData} areaData The AreaData object (a collection of area elements and metadata)
       * @param {object} options Rendering options to apply when rendering this group of areas
       */
      function addShapeGroupImpl(graphics, areaData, options) {
          var me = graphics,
              md = me.map_data,
              isMask = options.isMask;
  
          // first get area options. Then override fade for selecting, and finally merge in the 
          // "select" effect options.
  
          $.each(areaData.areas(), function (i,e) {
              options.isMask = isMask || (e.nohref && md.options.noHrefIsMask);
              me.addShape(e, options);
          });
  
          // it's faster just to manipulate the passed options isMask property and restore it, than to 
          // copy the object each time
          
          options.isMask=isMask;
  
      }
  
       /**
       * Convert a hex value to decimal
       * @param  {string} hex A hexadecimal toString
       * @return {int} Integer represenation of the hex string
       */
  
      function hex_to_decimal(hex) {
          return Math.max(0, Math.min(parseInt(hex, 16), 255));
      }
      function css3color(color, opacity) {
          return 'rgba(' + hex_to_decimal(color.substr(0, 2)) + ','
                  + hex_to_decimal(color.substr(2, 2)) + ','
                  + hex_to_decimal(color.substr(4, 2)) + ',' + opacity + ')';
      }
      /**
       * An object associated with a particular map_data instance to manage renderin.
       * @param {MapData} map_data The MapData object bound to this instance
       */
      
      m.Graphics = function (map_data) {
          //$(window).unload($.mapster.unload);
          // create graphics functions for canvas and vml browsers. usage:
          // 1) init with map_data, 2) call begin with canvas to be used (these are separate b/c may not require canvas to be specified
          // 3) call add_shape_to for each shape or mask, 4) call render() to finish
  
          var me = this;
          me.active = false;
          me.canvas = null;
          me.width = 0;
          me.height = 0;
          me.shapes = [];
          me.masks = [];
          me.map_data = map_data;
      };
      
      p = m.Graphics.prototype= {
          constructor: m.Graphics,
  
          /**
           * Initiate a graphics request for a canvas
           * @param  {Element} canvas The canvas element that is the target of this operation
           * @param  {string} [elementName] The name to assign to the element (VML only)
           */
          
          begin: function(canvas, elementName) {
              var c = $(canvas);
  
              this.elementName = elementName;
              this.canvas = canvas;
  
              this.width = c.width();
              this.height = c.height();
              this.shapes = [];
              this.masks = [];
              this.active = true;
  
          },
          
          /**
           * Add an area to be rendered to this canvas. 
           * @param {MapArea} mapArea The MapArea object to render
           * @param {object} options An object containing any rendering options that should override the
           *                         defaults for the area
           */
          
          addShape: function(mapArea, options) {
              var addto = options.isMask ? this.masks : this.shapes;
              addto.push({ mapArea: mapArea, options: options });
          },
  
          /**
           * Create a canvas that is sized and styled for the MapData object
           * @param  {MapData} mapData The MapData object that will receive this new canvas
           * @return {Element} A canvas element
           */
          
          createVisibleCanvas: function (mapData) {
              return $(this.createCanvasFor(mapData))
                  .addClass('mapster_el')
                  .css(m.canvas_style)[0];
          },
  
          /**
           * Add a group of shapes from an AreaData object to the canvas
           * 
           * @param {AreaData} areaData An AreaData object (a set of area elements)
           * @param {string} mode     The rendering mode, "select" or "highlight". This determines the target 
           *                          canvas and which default options to use.
           * @param {striong} options  Rendering options
           */
          
          addShapeGroup: function (areaData, mode,options) {
              // render includeKeys first - because they could be masks
              var me = this,
                  list, name, canvas,
                  map_data = this.map_data,
                  opts = areaData.effectiveRenderOptions(mode);
  
              if (options) {
                   $.extend(opts,options);
              }
  
              if (mode === 'select') {
                  name = "static_" + areaData.areaId.toString();
                  canvas = map_data.base_canvas;
              } else {
                  canvas = map_data.overlay_canvas;
              }
  
              me.begin(canvas, name);
  
              if (opts.includeKeys) {
                  list = u.split(opts.includeKeys);
                  $.each(list, function (i,e) {
                      var areaData = map_data.getDataForKey(e.toString());
                      addShapeGroupImpl(me,areaData, areaData.effectiveRenderOptions(mode));
                  });
              }
  
              addShapeGroupImpl(me,areaData, opts);
              me.render();
              if (opts.fade) {
                  
                  // fading requires special handling for IE. We must access the fill elements directly. The fader also has to deal with 
                  // the "opacity" attribute (not css)
  
                  u.fader(
  			m.hasCanvas() ? canvas : $(canvas).find('._fill').not('.mapster_mask'),
  			opts.noFade ? 1 : 0, /*new: added by mimicat*/
  			m.hasCanvas() ? 1 : opts.fillOpacity,
  			opts.fadeDuration
  		); 
                 
              }
  
          }
  
          // These prototype methods are implementation dependent
      };
  
      function noop() {}
  
    
      // configure remaining prototype methods for ie or canvas-supporting browser
  
      canvasMethods = {
          renderShape: function (context, mapArea, offset) {
              var i,
                  c = mapArea.coords(null,offset);
  
              switch (mapArea.shape) {
                  case 'rect':
                      context.rect(c[0], c[1], c[2] - c[0], c[3] - c[1]);
                      break;
                  case 'poly':
                      context.moveTo(c[0], c[1]);
  
                      for (i = 2; i < mapArea.length; i += 2) {
                          context.lineTo(c[i], c[i + 1]);
                      }
                      context.lineTo(c[0], c[1]);
                      break;
                  case 'circ':
                  case 'circle':
                      context.arc(c[0], c[1], c[2], 0, Math.PI * 2, false);
                      break;
              }
          },
          addAltImage: function (context, image, mapArea, options) {
              context.beginPath();
  
              this.renderShape(context, mapArea);
              context.closePath();
              context.clip();
  
              context.globalAlpha = options.altImageOpacity || options.fillOpacity;
  
              context.drawImage(image, 0, 0, mapArea.owner.scaleInfo.width, mapArea.owner.scaleInfo.height);
          },
          render: function () {
              // firefox 6.0 context.save() seems to be broken. to work around,  we have to draw the contents on one temp canvas,
              // the mask on another, and merge everything. ugh. fixed in 1.2.2. unfortunately this is a lot more code for masks,
              // but no other way around it that i can see.
  
              var maskCanvas, maskContext,
                          me = this,
                          md = me.map_data,
                          hasMasks = me.masks.length,
                          shapeCanvas = me.createCanvasFor(md),
                          shapeContext = shapeCanvas.getContext('2d'),
                          context = me.canvas.getContext('2d');
  
              if (hasMasks) {
                  maskCanvas = me.createCanvasFor(md);
                  maskContext = maskCanvas.getContext('2d');
                  maskContext.clearRect(0, 0, maskCanvas.width, maskCanvas.height);
  
                  $.each(me.masks, function (i,e) {
                      maskContext.save();
                      maskContext.beginPath();
                      me.renderShape(maskContext, e.mapArea);
                      maskContext.closePath();
                      maskContext.clip();
                      maskContext.lineWidth = 0;
                      maskContext.fillStyle = '#000';
                      maskContext.fill();
                      maskContext.restore();
                  });
  
              }
  
              $.each(me.shapes, function (i,s) {
                  shapeContext.save();
                  if (s.options.fill) {
                      if (s.options.altImageId) {
                          me.addAltImage(shapeContext, md.images[s.options.altImageId], s.mapArea, s.options);
                      } else {
                          shapeContext.beginPath();
                          me.renderShape(shapeContext, s.mapArea);
                          shapeContext.closePath();
                          //shapeContext.clip();
                          shapeContext.fillStyle = css3color(s.options.fillColor, s.options.fillOpacity);
                          shapeContext.fill();
                      }
                  }
                  shapeContext.restore();
              });
  
  
              // render strokes at end since masks get stroked too
  
              $.each(me.shapes.concat(me.masks), function (i,s) {
                  var offset = s.options.strokeWidth === 1 ? 0.5 : 0;
                  // offset applies only when stroke width is 1 and stroke would render between pixels.
  
                  if (s.options.stroke) {
                      shapeContext.save();
                      shapeContext.strokeStyle = css3color(s.options.strokeColor, s.options.strokeOpacity);
                      shapeContext.lineWidth = s.options.strokeWidth;
  
                      shapeContext.beginPath();
  
                      me.renderShape(shapeContext, s.mapArea, offset);
                      shapeContext.closePath();
                      shapeContext.stroke();
                      shapeContext.restore();
                  }
              });
  
              if (hasMasks) {
                  // render the new shapes against the mask
  
                  maskContext.globalCompositeOperation = "source-out";
                  maskContext.drawImage(shapeCanvas, 0, 0);
  
                  // flatten into the main canvas
                  context.drawImage(maskCanvas, 0, 0);
              } else {
                  context.drawImage(shapeCanvas, 0, 0);
              }
  
              me.active = false;
              return me.canvas;
          },
  
          // create a canvas mimicing dimensions of an existing element
          createCanvasFor: function (md) {
              return $('<canvas width="' + md.scaleInfo.width + '" height="' +md.scaleInfo.height + '"></canvas>')[0];
          },
          clearHighlight: function () {
              var c = this.map_data.overlay_canvas;
              c.getContext('2d').clearRect(0, 0, c.width, c.height);
          },
          // Draw all items from selected_list to a new canvas, then swap with the old one. This is used to delete items when using canvases.
          refreshSelections: function () {
              var canvas_temp, map_data = this.map_data;
              // draw new base canvas, then swap with the old one to avoid flickering
              canvas_temp = map_data.base_canvas;
  
              map_data.base_canvas = this.createVisibleCanvas(map_data);
              $(map_data.base_canvas).hide();
              $(canvas_temp).before(map_data.base_canvas);
  
              map_data.redrawSelections();
  
              $(map_data.base_canvas).show();
              $(canvas_temp).remove();
          }
      };
  
      vmlMethods = {
  
          renderShape: function (mapArea, options, cssclass) {
              var me = this, fill,stroke, e, t_fill, el_name, el_class, template, c = mapArea.coords();
              el_name = me.elementName ? 'name="' + me.elementName + '" ' : '';
              el_class = cssclass ? 'class="' + cssclass + '" ' : '';
  
              t_fill = '<v:fill color="#' + options.fillColor + '" class="_fill" opacity="' + 
                  (options.fill ? 
                      options.fillOpacity :
                      0) + 
                  '" /><v:stroke class="_fill" opacity="' + 
                  options.strokeOpacity + '"/>';
  
  
              stroke = options.stroke ?
                  ' strokeweight=' + options.strokeWidth + ' stroked="t" strokecolor="#' + 
                      options.strokeColor + '"' :
                  ' stroked="f"';
              
              fill = options.fill ? 
                  ' filled="t"' :
                  ' filled="f"';
  
              switch (mapArea.shape) {
                  case 'rect':
                      template = '<v:rect ' + el_class + el_name + fill + stroke + 
                          ' style="zoom:1;margin:0;padding:0;display:block;position:absolute;left:' + 
                            c[0] + 'px;top:' + c[1]  + 'px;width:' + (c[2] - c[0]) + 
                            'px;height:' + (c[3] - c[1]) + 'px;">' + t_fill + '</v:rect>';
                      break;
                  case 'poly':
                      template = '<v:shape ' + el_class + el_name + fill + stroke + ' coordorigin="0,0" coordsize="' + me.width + ',' + me.height
                                  + '" path="m ' + c[0] + ',' + c[1] + ' l ' + c.slice(2).join(',')
                                  + ' x e" style="zoom:1;margin:0;padding:0;display:block;position:absolute;top:0px;left:0px;width:' + me.width + 'px;height:' + me.height + 'px;">' + t_fill + '</v:shape>';
                      break;
                  case 'circ':
                  case 'circle':
                      template = '<v:oval ' + el_class + el_name + fill + stroke
                                  + ' style="zoom:1;margin:0;padding:0;display:block;position:absolute;left:' + (c[0] - c[2]) + 'px;top:' + (c[1] - c[2])
                                  + 'px;width:' + (c[2] * 2) + 'px;height:' + (c[2] * 2) + 'px;">' + t_fill + '</v:oval>';
                      break;
              }
              e = $(template);
              $(me.canvas).append(e);
  
              return e;
          },
          render: function () {
              var opts, me = this;
  
              $.each(this.shapes, function (i,e) {
                  me.renderShape(e.mapArea, e.options);
              });
  
              if (this.masks.length) {
                  $.each(this.masks, function (i,e) {
                      opts = u.updateProps({},
                          e.options, {
                              fillOpacity: 1,
                              fillColor: e.options.fillColorMask
                          });
                      me.renderShape(e.mapArea, opts, 'mapster_mask');
                  });
              }
  
              this.active = false;
              return this.canvas;
          },
  
          createCanvasFor: function (md) {
              var w = md.scaleInfo.width,
                  h = md.scaleInfo.height;
              return $('<var width="' + w + '" height="' + h 
                  + '" style="zoom:1;overflow:hidden;display:block;width:' 
                  + w + 'px;height:' + h + 'px;"></var>')[0];
          },
  
          clearHighlight: function () {
              $(this.map_data.overlay_canvas).children().remove();
          },
          // remove single or all selections
          removeSelections: function (area_id) {
              if (area_id >= 0) {
                  $(this.map_data.base_canvas).find('[name="static_' + area_id.toString() + '"]').remove();
              }
              else {
                  $(this.map_data.base_canvas).children().remove();
              }
          }
  
      };
  
      // for all methods with two implemenatations, add a function that will automatically replace itself with the correct
      // method on first invocation
      
      $.each(['renderShape',
             'addAltImage',
             'render',
             'createCanvasFor',
             'clearHighlight',
             'removeSelections',
             'refreshSelections'],
          function(i,e) {
              p[e]=(function(method) {
                  return function() {
                      p[method] = (m.hasCanvas() ?
                          canvasMethods[method] : 
                          vmlMethods[method]) || noop;
                    
                      return p[method].apply(this,arguments);
                  };
              }(e));
      });
  
  
  } (jQuery));
  /* mapimage.js
     the MapImage object, repesents an instance of a single bound imagemap
  */
  
  (function ($) {
  
      var m = $.mapster, 
          u = m.utils,
          ap=[];
      /**
       * An object encapsulating all the images used by a MapData.
       */
      
      m.MapImages = function(owner) {
          this.owner = owner;
          this.clear();
      };
  
      
      m.MapImages.prototype = {
          constructor: m.MapImages,
  
          /* interface to make this array-like */
  
          slice: function() {
              return ap.slice.apply(this,arguments);
          },
          splice: function() {
              ap.slice.apply(this.status,arguments);
              var result= ap.slice.apply(this,arguments);
              return result;
          },
       
          /** 
           * a boolean value indicates whether all images are done loading 
           * @return {bool} true when all are done
           */
          complete: function() {
              return $.inArray(false, this.status) < 0;
          },
          
          /**
           * Save an image in the images array and return its index 
           * @param  {Image} image An Image object
           * @return {int} the index of the image
           */
          
          _add: function(image) {
              var index = ap.push.call(this,image)-1;
              this.status[index] = false;
              return index;
          },
  
          /**
           * Return the index of an Image within the images array
           * @param  {Image} img An Image
           * @return {int} the index within the array, or -1 if it was not found
           */
          
          indexOf: function(image) {
              return $.inArray(image, this);
          },
          
          /**
           * Clear this object and reset it to its initial state after binding.
           */
          
          clear: function() {
              var me=this;
  
              if (me.ids && me.ids.length>0) {
                  $.each(me.ids,function(i,e) {
                      delete me[e];
                  });
              }
              
              /**
               * A list of the cross-reference IDs bound to this object
               * @type {string[]}
               */
              
              me.ids=[];
  
              /**
               * Length property for array-like behavior, set to zero when initializing. Array prototype
               * methods will update it after that.
               * 
               * @type {int}
               */
              
              me.length=0;
  
              /**
               * the loaded status of the corresponding image
               * @type {boolean[]}
               */
              
              me.status=[];
              
              
              // actually erase the images
              
              me.splice(0);
              
          },
  
          /**
           * Bind an image to the map and add it to the queue to be loaded; return an ID that
           * can be used to reference the
           * 
           * @param {Image|string} image An Image object or a URL to an image
           * @param {string} [id] An id to refer to this image
           * @returns {int} an ID referencing the index of the image object in 
           *                map_data.images
           */
       
          add: function(image,id) {
              var index,src,me = this;
  
              if (!image) { return; }
  
              if (typeof image === 'string') {
                  src = image;
                  image = me[src];
                  if (typeof image==='object') {
                      return me.indexOf(image);
                  }
  
                  image = $('<img />')
                      .addClass('mapster_el')
                      .hide();
  
                  index=me._add(image[0]);
                  
                  image
                      .bind('load',function(e) {
                          me.imageLoaded.call(me,e);
                      })
                      .bind('error',function(e) {
                          me.imageLoadError.call(me,e);
                      });
                  
                  image.attr('src', src);
              } else {
  
                  // use attr because we want the actual source, not the resolved path the browser will return directly calling image.src
                  
                  index=me._add($(image)[0]);
              }
              if (id) {
                  if (this[id]) {
                      throw(id+" is already used or is not available as an altImage alias.");
                  }
                  me.ids.push(id);
                  me[id]=me[index];
              }
              return index;
          },
  
          /**
           * Bind the images in this object, 
           * @param  {boolean} retry when true, indicates that the function is calling itself after failure 
           * @return {Promise} a promise that resolves when the images have finished loading
           */
          
          bind: function(retry) {
              var me = this,
                  promise,
                  triesLeft = me.owner.options.configTimeout / 200,
  
              /* A recursive function to continue checking that the images have been 
                 loaded until a timeout has elapsed */
  
              check=function() {
                  var i;
  
                  // refresh status of images
                  
                  i=me.length;
  
                  while (i-->0) {
                      if (!me.isLoaded(i)) {
                          break;
                      }
                  }
  
                  // check to see if every image has already been loaded
                  
                  if (me.complete()) {
                      me.resolve();
                  } else {
                      // to account for failure of onLoad to fire in rare situations
                      if (triesLeft-- > 0) {
                          me.imgTimeout=window.setTimeout(function() {
                              check.call(me,true);
                          }, 50);
                      } else {
                          me.imageLoadError.call(me);
                      }
                  }
              
              };
  
              promise = me.deferred=u.defer();
              
              check();
              return promise;
          },
     
          resolve: function() {
              var me=this,
                  resolver=me.deferred;
                  
              if (resolver) {
                  // Make a copy of the resolver before calling & removing it to ensure
                  // it is not called twice
                  me.deferred=null;
                  resolver.resolve();
              }
          },
  
          /**
           * Event handler for image onload
           * @param  {object} e jQuery event data
           */
          
          imageLoaded: function(e) {
              var me=this,
                  index = me.indexOf(e.target);
  
              if (index>=0) {
  
                  me.status[index] = true;
                  if ($.inArray(false, me.status) < 0) {
                      me.resolve();
                  }
              }
          },
          
          /**
           * Event handler for onload error
           * @param  {object} e jQuery event data
           */
          
          imageLoadError: function(e) {
              clearTimeout(this.imgTimeout);
              this.triesLeft=0;
              var err = e ? 'The image ' + e.target.src + ' failed to load.' : 
                  'The images never seemed to finish loading. You may just need to increase the configTimeout if images could take a long time to load.';
              throw err;
          },
          /**
           * Test if the image at specificed index has finished loading
           * @param  {int}  index The image index
           * @return {boolean} true if loaded, false if not
           */
          
          isLoaded: function(index) {
              var img,
                  me=this,
                  status=me.status;
  
              if (status[index]) { return true; }
              img = me[index];
              
              if (typeof img.complete !== 'undefined') {
                  status[index]=img.complete;
              } else {
                  status[index]=!!u.imgWidth(img);
              }
              // if complete passes, the image is loaded, but may STILL not be available because of stuff like adblock.
              // make sure it is.
  
              return status[index];
          }
      };
      } (jQuery));
  /* mapdata.js
     the MapData object, repesents an instance of a single bound imagemap
  */
  
  
  (function ($) {
  
      var m = $.mapster, 
          u = m.utils;
     
      /**
       * Set default values for MapData object properties
       * @param  {MapData} me The MapData object
       */
      
      function initializeDefaults(me) {
          $.extend(me,{
              complete: false,         // (bool)    when configuration is complete       
              map: null,                // ($)      the image map
              base_canvas: null,       // (canvas|var)  where selections are rendered
              overlay_canvas: null,    // (canvas|var)  where highlights are rendered
              commands: [],            // {}        commands that were run before configuration was completed (b/c images weren't loaded)
              data: [],                // MapData[] area groups
              mapAreas: [],            // MapArea[] list. AreaData entities contain refs to this array, so options are stored with each.
              _xref: {},               // (int)      xref of mapKeys to data[]
              highlightId: -1,        // (int)      the currently highlighted element.
              currentAreaId: -1,
              _tooltip_events: [],     // {}         info on events we bound to a tooltip container, so we can properly unbind them
              scaleInfo: null,         // {}         info about the image size, scaling, defaults
              index: -1,                 // index of this in map_cache - so we have an ID to use for wraper div
              activeAreaEvent: null
          });
      }
  
      /**
       * Return an array of all image-containing options from an options object; 
       * that is, containers that may have an "altImage" property
       * 
       * @param  {object} obj     An options object
       * @return {object[]}       An array of objects
       */
      function getOptionImages(obj) {
          return [obj, obj.render_highlight, obj.render_select];
      }
  
      /**
       * Parse all the altImage references, adding them to the library so they can be preloaded
       * and aliased.
       * 
       * @param  {MapData} me The MapData object on which to operate
       */
      function configureAltImages(me)
      {
          var opts = me.options,
              mi = me.images;
  
          // add alt images
          
          if (m.hasCanvas()) {
              // map altImage library first
              
              $.each(opts.altImages || {}, function(i,e) {
                  mi.add(e,i);
              });
              
              // now find everything else
  
              $.each([opts].concat(opts.areas),function(i,e) {
                  $.each(getOptionImages(e),function(i2,e2) {
                      if (e2 && e2.altImage) {
                          e2.altImageId=mi.add(e2.altImage);
                      }
                  });
              });
          }
  
          // set area_options
          me.area_options = u.updateProps({}, // default options for any MapArea
              m.area_defaults,
              opts);
      }
  
      /**
       * Queue a mouse move action based on current delay settings 
       * (helper for mouseover/mouseout handlers)
       * 
       * @param  {MapData}    me       The MapData context
       * @param  {number}     delay    The number of milliseconds to delay the action
       * @param  {AreaData}   area     AreaData affected
       * @param  {Deferred}   deferred A deferred object to return (instead of a new one)
       * @return {Promise}    A promise that resolves when the action is completed
       */
      function queueMouseEvent(me,delay,area, deferred) {
          
          deferred = deferred || u.when.defer();
  
          function cbFinal(areaId) {
              if (me.currentAreaId!==areaId && me.highlightId>=0) {
                  deferred.resolve();
              }
          }
          if (me.activeAreaEvent) {
              window.clearTimeout(me.activeAreaEvent);
              me.activeAreaEvent=0;
          }
          if (delay<0) {
              return;
          }
  
          if (area.owner.currentAction || delay) {
              me.activeAreaEvent = window.setTimeout((function() {
                      return function() {
                          queueMouseEvent(me,0,area,deferred);
                      };
                  }(area)),
                  delay || 100);
          } else {
               cbFinal(area.areaId);
          }
          return deferred;
      }
  
       /**
       * Mousedown event. This is captured only to prevent browser from drawing an outline around an
       * area when it's clicked.
       *
       * @param  {EventData} e jQuery event data
       */
      
      function mousedown(e) {
          if (!m.hasCanvas()) {
              this.blur();
          }
          e.preventDefault();
      }
  
      /**
       * Mouseover event. Handle highlight rendering and client callback on mouseover
       * 
       * @param  {MapData} me The MapData context
       * @param  {EventData} e jQuery event data
       * @return {[type]}   [description]
       */
      
      function mouseover(me,e) {
          var arData = me.getAllDataForArea(this),
              ar=arData.length ? arData[0] : null;
  
          // mouseover events are ignored entirely while resizing, though we do care about mouseout events
          // and must queue the action to keep things clean.
  
          if (!ar || ar.isNotRendered() || ar.owner.currentAction) {
              return;
          }
  
          if (me.currentAreaId === ar.areaId) {
              return;
          }
          if (me.highlightId !== ar.areaId) {
              me.clearEffects();
  
              ar.highlight();
  
              if (me.options.showToolTip) {
                  $.each(arData,function(i,e) {
                      if (e.effectiveOptions().toolTip) {
                          e.showToolTip();
                      }
                  });
              }
          }
  
          me.currentAreaId = ar.areaId;
  
          if ($.isFunction(me.options.onMouseover)) {
              me.options.onMouseover.call(this,
              {
                  e: e,
                  options:ar.effectiveOptions(),
                  key: ar.key,
                  selected: ar.isSelected()
              });
          }
      }
  
      /**
       * Mouseout event.
       *
       * @param  {MapData} me The MapData context
       * @param  {EventData} e jQuery event data
       * @return {[type]}   [description]
       */
      
      function mouseout(me,e) {
          var newArea,
              ar = me.getDataForArea(this),
              opts = me.options;
  
  
          if (me.currentAreaId<0 || !ar) {
              return;
          }
  
          newArea=me.getDataForArea(e.relatedTarget);
          
          if (newArea === ar) {
              return;
          }
  
          me.currentAreaId = -1;
          ar.area=null;
  
  	if(!opts.permanentHover){
  		queueMouseEvent(me,opts.mouseoutDelay,ar).then(me.clearEffects);
  	}
  
          if ($.isFunction(opts.onMouseout)) {
              opts.onMouseout.call(this,
              {
                  e: e,
                  options: opts,
                  key: ar.key,
                  selected: ar.isSelected()
              });
          }
  
      }
      
      /**
       * Clear any active tooltip or highlight
       *
       * @param  {MapData} me The MapData context
       * @param  {EventData} e jQuery event data
       * @return {[type]}   [description]
       */
      
      function clearEffects(me) {
          var opts = me.options;
  
          me.ensureNoHighlight();
  
          if (opts.toolTipClose 
              && $.inArray('area-mouseout', opts.toolTipClose) >= 0 
              && me.activeToolTip) 
          {
              me.clearToolTip();
          }
      }
  
      /**
       * Mouse click event handler
       *
       * @param  {MapData} me The MapData context
       * @param  {EventData} e jQuery event data
       * @return {[type]}   [description]
       */
      
      function click(me,e) {
          var selected, list, list_target, newSelectionState, canChangeState, cbResult,
              that = this,
              ar = me.getDataForArea(this),
              opts = me.options;
  
          function clickArea(ar) {
              var areaOpts,target;
              canChangeState = (ar.isSelectable() &&
                  (ar.isDeselectable() || !ar.isSelected()));
              
              if (canChangeState) {
                  newSelectionState = !ar.isSelected();
              } else {
                  newSelectionState = ar.isSelected();
              }
  
              list_target = m.getBoundList(opts, ar.key);
  
              if ($.isFunction(opts.onClick)) 
              {
                  cbResult= opts.onClick.call(that,
                  {
                      e: e,
                      listTarget: list_target,
                      key: ar.key,
                      selected: newSelectionState,
  		    options:ar.effectiveOptions() /*new: added by mimicat*/
                  });
  
                  if (u.isBool(cbResult)) {
                      if (!cbResult) {
                          return false;
                      }
                      target = $(ar.area).attr('href');
                      if (target!=='#') {
                          window.location.href=target;
                          return false;
                      }
                  }
              }
  
              if (canChangeState) {
                  selected = ar.toggle();
              }
  
              if (opts.boundList && opts.boundList.length > 0) {
                  m.setBoundListProperties(opts, list_target, ar.isSelected());
              }
  
              areaOpts = ar.effectiveOptions();
              if (areaOpts.includeKeys) {
                  list = u.split(areaOpts.includeKeys);
                  $.each(list, function (i, e) {
                      var ar = me.getDataForKey(e.toString());
                      if (!ar.options.isMask) {
                          clickArea(ar);
                      }
                  });
              }
          }
  
          mousedown.call(this,e);
  
          if (opts.clickNavigate && ar.href) {
              window.location.href=ar.href;
              return;
          }
  
          if (ar && !ar.owner.currentAction) {
              opts = me.options;
              clickArea(ar);
          }
      }
  
      /**
       * Prototype for a MapData object, representing an ImageMapster bound object
       * @param {Element} image   an IMG element
       * @param {object} options  ImageMapster binding options
       */
      m.MapData = function (image, options) 
      {
          var me = this;
          
          // (Image)  main map image
          
          me.image = image;              
  
          me.images = new m.MapImages(me); 
          me.graphics = new m.Graphics(me);
  
          // save the initial style of the image for unbinding. This is problematic, chrome 
          // duplicates styles when assigning, and cssText is apparently not universally supported.
          // Need to do something more robust to make unbinding work universally.
          
          me.imgCssText = image.style.cssText || null;
  
          initializeDefaults(me);
  
          me.configureOptions(options);
          
          // create context-bound event handlers from our private functions
          
          me.mouseover = function(e) { mouseover.call(this,me,e); };
          me.mouseout = function(e) { mouseout.call(this,me,e); };
          me.click = function(e) { click.call(this,me,e); };
          me.clearEffects = function(e) { clearEffects.call(this,me,e); };
      };
  
      m.MapData.prototype = {
          constructor: m.MapData,
  
           /**
           * Set target.options from defaults + options
           * @param  {[type]} target      The target
           * @param  {[type]} options     The options to merge
           */
          
          configureOptions: function(options) {
              this.options= u.updateProps({}, m.defaults, options);
          },
  
          /**
           * Ensure all images are loaded
           * @return {Promise} A promise that resolves when the images have finished loading (or fail)
           */
      
          bindImages: function() {
              var me=this,
                  mi = me.images;
  
              // reset the images if this is a rebind
              
              if (mi.length>2) {
                  mi.splice(2);
              } else if (mi.length===0) {
  
                  // add the actual main image
                  mi.add(me.image);
                  // will create a duplicate of the main image, we need this to get raw size info
                  mi.add(me.image.src);
              }
              
              configureAltImages(me);
  
              return me.images.bind();
          },
  
          /**
           * Test whether an async action is currently in progress
           * @return {Boolean} true or false indicating state
           */
          
          isActive: function() {
              return !this.complete || this.currentAction;
          },
  
          /**
           * Return an object indicating the various states. This isn't really used by 
           * production code.
           * 
           * @return {object} An object with properties for various states
           */
          
          state: function () {
              return {
                  complete: this.complete,
                  resizing: this.currentAction==='resizing',
                  zoomed: this.zoomed,
                  zoomedArea: this.zoomedArea,
                  scaleInfo: this.scaleInfo
              };
          },   
  
          /**
           * Get a unique ID for the wrapper of this imagemapster
           * @return {string} A string that is unique to this image
           */
          
          wrapId: function () {
              return 'mapster_wrap_' + this.index;
          },
          _idFromKey: function (key) {
              return typeof key === "string" && this._xref.hasOwnProperty(key) ?
                          this._xref[key] : -1;
          },
  
          /**
           * Return a comma-separated string of all selected keys
           * @return {string} CSV of all keys that are currently selected
           */
          
          getSelected: function () {
              var result = '';
              $.each(this.data, function (i,e) {
                  if (e.isSelected()) {
                      result += (result ? ',' : '') + this.key;
                  }
              });
              return result;
          },
  
          /**
           * Get an array of MapAreas associated with a specific AREA based on the keys for that area
           * @param  {Element} area   An HTML AREA
           * @param  {number} atMost  A number limiting the number of areas to be returned (typically 1 or 0 for no limit)
           * @return {MapArea[]}      Array of MapArea objects
           */
          
          getAllDataForArea:function (area,atMost) {
              var i,ar, result,
                  me=this,
                  key = $(area).filter('area').attr(me.options.mapKey);
  
              if (key) {
                  result=[];
                  key = u.split(key);
  
                  for (i=0;i<(atMost || key.length);i++) {
                      ar = me.data[me._idFromKey(key[i])];
                      ar.area=area.length ? area[0]:area;
                      // set the actual area moused over/selected
                      // TODO: this is a brittle model for capturing which specific area - if this method was not used,
                      // ar.area could have old data. fix this.
                      result.push(ar);
                  }
              }
  
              return result;
          },
          getDataForArea: function(area) {
              var ar=this.getAllDataForArea(area,1);
              return ar ? ar[0] || null : null;
          },
          getDataForKey: function (key) {
              return this.data[this._idFromKey(key)];
          },
          
          /**
           * Get the primary keys associated with an area group.
           * If this is a primary key, it will be returned.
           * 
           * @param  {string key An area key
           * @return {string} A CSV of area keys
           */
          
          getKeysForGroup: function(key) {
              var ar=this.getDataForKey(key);
              
              return !ar ? '':
                  ar.isPrimary ? 
                      ar.key :
                      this.getPrimaryKeysForMapAreas(ar.areas()).join(',');
          },
          
          /**
           * given an array of MapArea object, return an array of its unique primary keys
           * @param  {MapArea[]} areas The areas to analyze
           * @return {string[]} An array of unique primary keys
           */
          
          getPrimaryKeysForMapAreas: function(areas)
          {
              var keys=[];
              $.each(areas,function(i,e) {
                  if ($.inArray(e.keys[0],keys)<0) {
                      keys.push(e.keys[0]);
                  }
              });
              return keys;
          },
          getData: function (obj) {
              if (typeof obj === 'string') {
                  return this.getDataForKey(obj);
              } else if (obj && obj.mapster || u.isElement(obj)) {
                  return this.getDataForArea(obj);
              } else {
                  return null;
              }
          },
          // remove highlight if present, raise event
          ensureNoHighlight: function () {
              var ar;
              if (this.highlightId >= 0) {
                  this.graphics.clearHighlight();
                  ar = this.data[this.highlightId];
                  ar.changeState('highlight', false);
                  this.setHighlightId(-1);
              }
          },
          setHighlightId: function(id) {
              this.highlightId = id;
          },
          getHighlightId: function() {
              return this.highlightId;
          },
          
          /**
           * Clear all active selections on this map
           */
          
          clearSelections: function () {
              $.each(this.data, function (i,e) {
                  if (e.selected) {
                      e.deselect(true);
                   }
              });
              this.removeSelectionFinish();
              
          },
  
          /**
           * Set area options from an array of option data.
           * 
           * @param {object[]} areas An array of objects containing area-specific options
           */
          
          setAreaOptions: function (areas) {
              var i, area_options, ar;
              areas = areas || [];
  
              // refer by: map_data.options[map_data.data[x].area_option_id]
              
              for (i = areas.length - 1; i >= 0; i--) {
                  area_options = areas[i];
                  if (area_options) {
                      ar = this.getDataForKey(area_options.key);
                      if (ar) {
                          u.updateProps(ar.options, area_options);
                          
                          // TODO: will not deselect areas that were previously selected, so this only works
                          // for an initial bind.
                          
                          if (u.isBool(area_options.selected)) {
                              ar.selected = area_options.selected;
                          }
                      }
                  }
              }
          },
          // keys: a comma-separated list
          drawSelections: function (keys) {
              var i, key_arr = u.asArray(keys);
  
              for (i = key_arr.length - 1; i >= 0; i--) {
                  this.data[key_arr[i]].drawSelection();
              }
          },
          redrawSelections: function () {
              $.each(this.data, function (i, e) {
                  if (e.isSelectedOrStatic()) {
                      e.drawSelection();
                  }
              });
  
          },
          ///called when images are done loading
          initialize: function () {
              var imgCopy, base_canvas, overlay_canvas, wrap, parentId, css, i,size,
                  img,sort_func, sorted_list,  scale,  
                          me = this,
                          opts = me.options;
  
              if (me.complete) {
                  return;
              }
  
              img = $(me.image);
              
              parentId = img.parent().attr('id');
  
              // create a div wrapper only if there's not already a wrapper, otherwise, own it
              
              if (parentId && parentId.length >= 12 && parentId.substring(0, 12) === "mapster_wrap") {
                  wrap = img.parent();
                  wrap.attr('id', me.wrapId());
              } else {
                  wrap = $('<div id="' + me.wrapId() + '"></div>');
  
                  if (opts.wrapClass) {
                      if (opts.wrapClass === true) {
                          wrap.addClass(img[0].className);
                      }
                      else {
                          wrap.addClass(opts.wrapClass);
                      }
                  }
              }
              me.wrapper = wrap;
              
              // me.images[1] is the copy of the original image. It should be loaded & at its native size now so we can obtain the true
              // width & height. This is needed to scale the imagemap if not being shown at its native size. It is also needed purely
              // to finish binding in case the original image was not visible. It can be impossible in some browsers to obtain the
              // native size of a hidden image.
  
              me.scaleInfo = scale = u.scaleMap(me.images[0],me.images[1], opts.scaleMap);
              
              me.base_canvas = base_canvas = me.graphics.createVisibleCanvas(me);
              me.overlay_canvas = overlay_canvas = me.graphics.createVisibleCanvas(me);
  
              // Now we got what we needed from the copy -clone from the original image again to make sure any other attributes are copied
              imgCopy = $(me.images[1])
                  .addClass('mapster_el '+ me.images[0].className)
                  .attr({id:null, usemap: null});
                  
              size=u.size(me.images[0]);
              
              if (size.complete) {
                  imgCopy.css({
                      width: size.width,
                      height: size.height
                  });
              }
       
              me.buildDataset();
  
              // now that we have processed all the areas, set css for wrapper, scale map if needed
  
              css = {
                  display: 'block',
                  position: 'relative',
                  padding: 0,
                  width: scale.width,
                  height: scale.height
              };
  
              if (opts.wrapCss) {
                  $.extend(css, opts.wrapCss);
              }
              // if we were rebinding with an existing wrapper, the image will aready be in it
              if (img.parent()[0] !== me.wrapper[0]) {
  
                  img.before(me.wrapper);
              }
  
              wrap.css(css);
  
              // move all generated images into the wrapper for easy removal later
  
              $(me.images.slice(2)).hide();
              for (i = 1; i < me.images.length; i++) {
                  wrap.append(me.images[i]);
              }
  
              //me.images[1].style.cssText = me.image.style.cssText;
  
              wrap.append(base_canvas)
                          .append(overlay_canvas)
                          .append(img.css(m.canvas_style));
  
              // images[0] is the original image with map, images[1] is the copy/background that is visible
  
              u.setOpacity(me.images[0], 0);
              $(me.images[1]).show();
  
              u.setOpacity(me.images[1],1);
  
              if (opts.isSelectable && opts.onGetList) {
                  sorted_list = me.data.slice(0);
                  if (opts.sortList) {
                      if (opts.sortList === "desc") {
                          sort_func = function (a, b) {
                              return a === b ? 0 : (a > b ? -1 : 1);
                          };
                      }
                      else {
                          sort_func = function (a, b) {
                              return a === b ? 0 : (a < b ? -1 : 1);
                          };
                      }
  
                      sorted_list.sort(function (a, b) {
                          a = a.value;
                          b = b.value;
                          return sort_func(a, b);
                      });
                  }
  
                  me.options.boundList = opts.onGetList.call(me.image, sorted_list);
              }
              
              me.complete=true;
              me.processCommandQueue();
              
              if (opts.onConfigured && typeof opts.onConfigured === 'function') {
                  opts.onConfigured.call(img, true);
              }
          },
  
          // when rebind is true, the MapArea data will not be rebuilt.
          buildDataset: function(rebind) {
              var sel,areas,j,area_id,$area,area,curKey,mapArea,key,keys,mapAreaId,group_value,dataItem,href,
                  me=this,
                  opts=me.options,
                  default_group;
  
              function addAreaData(key, value) {
                  var dataItem = new m.AreaData(me, key, value);
                  dataItem.areaId = me._xref[key] = me.data.push(dataItem) - 1;
                  return dataItem.areaId;
              }
  
              me._xref = {};
              me.data = [];
              if (!rebind) {
                  me.mapAreas=[];
              }
  
              default_group = !opts.mapKey;
              if (default_group) {
                  opts.mapKey = 'data-mapster-key';
              }
  
              // the [attribute] selector is broken on old IE with jQuery. hasVml() is a quick and dirty
              // way to test for that
              
              sel = m.hasVml() ? 'area' :
                          (default_group ? 
                              'area[coords]' : 
                              'area[' + opts.mapKey + ']');
  
              areas = $(me.map).find(sel).unbind('.mapster');
                          
              for (mapAreaId = 0;mapAreaId<areas.length; mapAreaId++) {
                  area_id = 0;
                  area = areas[mapAreaId];
                  $area = $(area);
  
                  // skip areas with no coords - selector broken for older ie
                  if (!area.coords) {
                      continue;
                  }
                  // Create a key if none was assigned by the user
  
                  if (default_group) {
                       curKey=String(mapAreaId);
                      $area.attr('data-mapster-key', curKey);
                     
                  } else {
                      curKey = area.getAttribute(opts.mapKey);
                  }
  
                  // conditions for which the area will be bound to mouse events
                  // only bind to areas that don't have nohref. ie 6&7 cannot detect the presence of nohref, so we have to also not bind if href is missing.
  
                  if (rebind) {
                      mapArea = me.mapAreas[$area.data('mapster')-1];
                      mapArea.configure(curKey);
                  } else {
                      mapArea = new m.MapArea(me, area,curKey);
                      me.mapAreas.push(mapArea);
                  }
  
                  keys = mapArea.keys; // converted to an array by mapArea
  
  
                  // Iterate through each mapKey assigned to this area
                  for (j = keys.length - 1; j >= 0; j--) {
                      key = keys[j];
  
                      if (opts.mapValue) {
                          group_value = $area.attr(opts.mapValue);
                      }
                      if (default_group) {
                          // set an attribute so we can refer to the area by index from the DOM object if no key
                          area_id = addAreaData(me.data.length, group_value);
                          dataItem = me.data[area_id];
                          dataItem.key = key = area_id.toString();
                      }
                      else {
                          area_id = me._xref[key];
                          if (area_id >= 0) {
                              dataItem = me.data[area_id];
                              if (group_value && !me.data[area_id].value) {
                                  dataItem.value = group_value;
                              }
                          }
                          else {
                              area_id = addAreaData(key, group_value);
                              dataItem = me.data[area_id];
                              dataItem.isPrimary=j===0;
                          }
                      }
                      mapArea.areaDataXref.push(area_id);
                      dataItem.areasXref.push(mapAreaId);
                  }
  
                  href=$area.attr('href');
                  if (href && href!=='#' && !dataItem.href)
                  {
                      dataItem.href=href;
                  }
  
                  if (!mapArea.nohref) {
                      $area.bind('vclick.mapster', me.click);
                         
                      if (!m.isTouch) {
                          $area.bind('vmouseover.mapster', me.mouseover)
                              .bind('vmouseout.mapster', me.mouseout)
                              .bind('vmousedown.mapster', me.mousedown);
                          
                      }
                          
                  }
  
                  // store an ID with each area. 
                  $area.data("mapster", mapAreaId+1);
              }
             
              // TODO listenToList
              //            if (opts.listenToList && opts.nitG) {
              //                opts.nitG.bind('click.mapster', event_hooks[map_data.hooks_index].listclick_hook);
              //            }
  
              // populate areas from config options
              me.setAreaOptions(opts.areas);
              me.redrawSelections();
  
          },
          processCommandQueue: function() {
              
              var cur,me=this;
              while (!me.currentAction && me.commands.length) {
                  cur = me.commands[0];
                  me.commands.splice(0,1);
                  m.impl[cur.command].apply(cur.that, cur.args);
              }
          },
          clearEvents: function () {
              $(this.map).find('area')
                          .unbind('.mapster');
              $(this.images)
                          .unbind('.mapster');
          },
          _clearCanvases: function (preserveState) {
              // remove the canvas elements created
              if (!preserveState) {
                  $(this.base_canvas).remove();
              }
              $(this.overlay_canvas).remove();
          },
          clearMapData: function (preserveState) {
              var me = this;
              this._clearCanvases(preserveState);
  
              // release refs to DOM elements
              $.each(this.data, function (i, e) {
                  e.reset();
              });
              this.data = null;
              if (!preserveState) {
                  // get rid of everything except the original image
                  this.image.style.cssText = this.imgCssText;
                  $(this.wrapper).before(this.image).remove();
              }
  
              me.images.clear();
  
              this.image = null;
              u.ifFunction(this.clearTooltip, this);
          },
  
          // Compelete cleanup process for deslecting items. Called after a batch operation, or by AreaData for single
          // operations not flagged as "partial"
          
          removeSelectionFinish: function () {
              var g = this.graphics;
  
              g.refreshSelections();
              // do not call ensure_no_highlight- we don't really want to unhilight it, just remove the effect
              g.clearHighlight();
          }
      };
  } (jQuery));
  /* areadata.js
     AreaData and MapArea protoypes
  */
  
  (function ($) {
      var m = $.mapster, u = m.utils;
      
      /**
       * Select this area
       * 
       * @param {AreaData} me  AreaData context
       * @param {object} options Options for rendering the selection
       */
      function select(options) {
          // need to add the new one first so that the double-opacity effect leaves the current one highlighted for singleSelect
          
          var me=this, o = me.owner;
          if (o.options.singleSelect) {
              o.clearSelections();
          }
  
          // because areas can overlap - we can't depend on the selection state to tell us anything about the inner areas.
          // don't check if it's already selected
          if (!me.isSelected()) {
              if (options) {
                  
                  // cache the current options, and map the altImageId if an altimage 
                  // was passed
  
                  me.optsCache = $.extend(me.effectiveRenderOptions('select'),
                      options,
                      { 
                          altImageId: o.images.add(options.altImage)
                      });
              }
  
              me.drawSelection();
  
              me.selected = true;
              me.changeState('select', true);
          }
  
          if (o.options.singleSelect) {
              o.graphics.refreshSelections();
          }
      }
  
      /**
       * Deselect this area, optionally deferring finalization so additional areas can be deselected
       * in a single operation
       * 
       * @param  {boolean} partial when true, the caller must invoke "finishRemoveSelection" to render 
       */
      
      function deselect(partial) {
          var me=this;
          me.selected = false;
          me.changeState('select', false);
  
          // release information about last area options when deselecting.
          
          me.optsCache=null;
          me.owner.graphics.removeSelections(me.areaId);
  
          // Complete selection removal process. This is separated because it's very inefficient to perform the whole
          // process for multiple removals, as the canvas must be totally redrawn at the end of the process.ar.remove
          
          if (!partial) {
              me.owner.removeSelectionFinish();
          }
      }
  
      /**
       * Toggle the selection state of this area
       * @param  {object} options Rendering options, if toggling on
       * @return {bool} The new selection state
       */
      function toggle(options) {
          var me=this;
          if (!me.isSelected()) {
              me.select(options);
          }
          else {
              me.deselect();
          }
          return me.isSelected();
      }
  
      /**
       * An AreaData object; represents a conceptual area that can be composed of 
       * one or more MapArea objects
       * 
       * @param {MapData} owner The MapData object to which this belongs
       * @param {string} key   The key for this area
       * @param {string} value The mapValue string for this area
       */
      
      m.AreaData = function (owner, key, value) {
          $.extend(this,{
              owner: owner, 
              key: key || '',
              // means this represents the first key in a list of keys (it's the area group that gets highlighted on mouseover)
              isPrimary: true,
              areaId: -1,
              href: '',
              value: value || '',
              options:{},
              // "null" means unchanged. Use "isSelected" method to just test true/false 
              selected: null,       
              // xref to MapArea objects
              areasXref: [],
              // (temporary storage) - the actual area moused over
              area: null,
              // the last options used to render this. Cache so when re-drawing after a remove, changes in options won't
              // break already selected things. 
              optsCache: null
           });
      };
  
      /**
       * The public API for AreaData object
       */
  
      m.AreaData.prototype = {
          constuctor: m.AreaData,
          select: select,
          deselect: deselect,
          toggle: toggle,
          areas: function() {
              var i,result=[];
              for (i=0;i<this.areasXref.length;i++) {
                  result.push(this.owner.mapAreas[this.areasXref[i]]);
              }
              return result;
          },
          // return all coordinates for all areas
          coords: function(offset) {
              var coords = [];
              $.each(this.areas(), function (i, el) {
                  coords = coords.concat(el.coords(offset));
              });
              return coords;
          },
          reset: function () {
              $.each(this.areas(), function (i, e) {
                  e.reset();
              });
              this.areasXref = [];
              this.options = null;
          },
          // Return the effective selected state of an area, incorporating staticState
          isSelectedOrStatic: function () {
  
              var o = this.effectiveOptions();
              return u.isBool(o.staticState) ? o.staticState :
                          this.isSelected();
          },
          isSelected: function () {
              return u.isBool(this.selected) ? this.selected :
                  u.isBool(this.owner.area_options.selected) ? this.owner.area_options.selected : false;
          },
          isSelectable: function () {
              return u.isBool(this.effectiveOptions().staticState) ? false :
                          (u.isBool(this.owner.options.staticState) ? false : u.boolOrDefault(this.effectiveOptions().isSelectable,true));
          },
          isDeselectable: function () {
              return u.isBool(this.effectiveOptions().staticState) ? false :
                          (u.isBool(this.owner.options.staticState) ? false : u.boolOrDefault(this.effectiveOptions().isDeselectable,true));
          },
          isNotRendered: function() {
              var area = $(this.area);
              return area.attr('nohref') ||
                  !area.attr('href') ||
                  this.effectiveOptions().isMask;
  
          },
  
          
           /**
           * Return the overall options effective for this area. 
           * This should get the default options, and merge in area-specific options, finally
           * overlaying options passed by parameter
           * 
           * @param  {[type]} options  options which will supercede all other options for this area
           * @return {[type]}          the combined options
           */
          
          effectiveOptions: function (options) {
              
              var opts = u.updateProps({},
                      this.owner.area_options,
                      this.options,
                      options || {},
                      {
                          id: this.areaId 
                      }
                  );
  
              opts.selected = this.isSelected();
              
              return opts;
          },
  
          /**
           * Return the options effective for this area for a "render" or "highlight" mode. 
           * This should get the default options, merge in the areas-specific options, 
           * and then the mode-specific options.
           * @param  {string} mode    'render' or 'highlight'
           * @param  {[type]} options  options which will supercede all other options for this area
           * @return {[type]}          the combined options
           */
          
          effectiveRenderOptions: function (mode, options) {
              var allOpts,opts=this.optsCache;
              
              if (!opts || mode==='highlight') {
                  allOpts = this.effectiveOptions(options);
                  opts = u.updateProps({},
                      allOpts,
                      allOpts["render_" + mode]
                  );
                      
                  if (mode!=='highlight') {
                      this.optsCache=opts;
                  }
              }
              return $.extend({},opts);
          },
  
          // Fire callback on area state change
          changeState: function (state_type, state) {
              if ($.isFunction(this.owner.options.onStateChange)) {
                  this.owner.options.onStateChange.call(this.owner.image,
                      {
                          key: this.key,
                          state: state_type,
                          selected: state
                      }
                  );
              }
          },
  
          // highlight this area
          highlight: function (options) {
  		var o = this.owner;
  		
  		/*new: added by mimicat*/
  		// dont hilight is area already hilighted
  		if(this.areaId == o.getHighlightId()) return;
              
  		if (this.effectiveOptions().highlight) {
  		    o.graphics.addShapeGroup(this, "highlight",options);
  		}
  		o.setHighlightId(this.areaId);
  		this.changeState('highlight', true);
          },
  
          // select this area. if "callEvent" is true then the state change event will be called. (This method can be used
          // during config operations, in which case no event is indicated)
          
          drawSelection: function () {
          
  
              this.owner.graphics.addShapeGroup(this, "select");
          
          }
  
  
      };
      // represents an HTML area
      m.MapArea = function (owner,areaEl,keys) {
          if (!owner) {
              return;
          }
          var me = this;
          me.owner = owner;   // a MapData object
          me.area = areaEl;
          me.areaDataXref=[]; // a list of map_data.data[] id's for each areaData object containing this
          me.originalCoords = [];
          $.each(u.split(areaEl.coords), function (i, el) {
              me.originalCoords.push(parseFloat(el));
          });
          me.length = me.originalCoords.length;
          me.shape = areaEl.shape.toLowerCase();
          me.nohref = areaEl.nohref || !areaEl.href;
          me.configure(keys);
      };
      m.MapArea.prototype= {
          constructor: m.MapArea,
          configure: function(keys) {
              this.keys = u.split(keys);
          },
          reset: function() {
              this.area=null;
          },
          coords: function (offset) {
              return $.map(this.originalCoords,function(e) {
                  return offset ? e : e+offset;
              });
          }
      };
  } (jQuery));
  /* areacorners.js
     determine the best place to put a box of dimensions (width,height) given a circle, rect or poly
  */
  
  (function ($) {
      var u=$.mapster.utils;
  
  
      /**
       * Compute positions that will place a target with dimensions [width,height] outside 
       * but near the boundaries of the elements "elements". When an imagemap is passed, the 
       *
       * @param  {Element|Element[]} elements An element or an array of elements (such as a jQuery object)
       * @param  {Element} image The image to which area elements are bound, if this is an image map.
       * @param  {Element} container The contianer in which the target must be constrained (or document, if missing)
       * @param  {int} width The width of the target object
       * @return {object} a structure with the x and y positions
       */
      u.areaCorners = function (elements, image, container, width, height) {
          var pos,found, minX, minY, maxX, maxY, bestMinX, bestMaxX, bestMinY, bestMaxY, curX, curY, nest, j,
             offsetx=0, 
             offsety=0,
             rootx,
             rooty,
             iCoords,radius,angle,el,
             coords=[];
  
          // if a single element was passed, map it to an array
          
          elements = elements.length ? 
              elements:
              [elements];
  
          container = container ? 
              $(container):
              $(document.body);
  
          // get the relative root of calculation
  
          pos = container.offset();
          rootx = pos.left;
          rooty = pos.top;
  
          // with areas, all we know about is relative to the top-left corner of the image. We need to add an offset compared to
          // the actual container. After this calculation, offsetx/offsety can be added to either the area coords, or the target's
          // absolute position to get the correct top/left boundaries of the container.
  
          if (image) {
              pos = $(image).offset();
              offsetx = pos.left;
              offsety = pos.top;
          }
  
          // map the coordinates of any type of shape to a poly and use the logic. simpler than using three different
          // calculation methods. Circles use a 20 degree increment for this estimation.
  
          for (j=0;j<elements.length;j++) 
          {
              el=elements[j];
              if (el.nodeName==='AREA') {
                  iCoords = u.split(el.coords,parseInt);
  
                  switch(el.shape) {
                      case 'circle':
                          curX=iCoords[0];
                          curY=iCoords[1];
                          radius=iCoords[2];
                          coords=[];
                          for (j=0;j<360;j+=20) {
                               angle=j*Math.PI/180;
                               coords.push(curX+radius*Math.cos(angle),curY+radius*Math.sin(angle));
                          }
                          break;
                        case 'rect':
                            coords.push(iCoords[0],iCoords[1],iCoords[2],iCoords[1],iCoords[2],iCoords[3],iCoords[0],iCoords[3]);
                            break;
                        default:
                            coords=coords.concat(iCoords);
                           break;
                  }
  
                  // map area positions to it's real position in the container
  
                  for (j=0;j<coords.length;j+=2)
                  {
                      coords[j]=parseInt(coords[j],10)+offsetx;
                      coords[j+1]=parseInt(coords[j+1],10)+offsety;
                  }
              } else {
                  el=$(el);
                  pos = el.position();
                  coords.push(pos.left,pos.top,
                              pos.left+el.width(),pos.top,
                              pos.left+el.width(),pos.top+el.height(),
                              pos.left,pos.top+el.height());
  
              }
          }
          
          minX = minY = bestMinX = bestMinY = 999999;
          maxX = maxY = bestMaxX = bestMaxY = -1;
  
          for (j = coords.length - 2; j >= 0; j -= 2) {
              curX = coords[j];
              curY = coords[j + 1];
              
              if (curX < minX) {
                  minX = curX;
                  bestMaxY = curY;
              }
              if (curX > maxX) {
                  maxX = curX;
                  bestMinY = curY;
              }
              if (curY < minY) {
                  minY = curY;
                  bestMaxX = curX;
              }
              if (curY > maxY) {
                  maxY = curY;
                  bestMinX = curX;
              }
  
          }
  
          // try to figure out the best place for the tooltip
          
          if (width && height) {
              found=false;
              $.each([[bestMaxX - width, minY - height], [bestMinX, minY - height],
                               [minX - width, bestMaxY - height], [minX - width, bestMinY],
                               [maxX,bestMaxY - height], [ maxX,bestMinY],
                               [bestMaxX - width, maxY], [bestMinX, maxY]
                        ],function (i, e) {
                            if (!found && (e[0] > rootx && e[1] > rooty)) {
                                nest = e;
                                found=true;
                                return false;
                    }
               });
               
               // default to lower-right corner if nothing fit inside the boundaries of the image
               
               if (!found) {
                   nest=[maxX,maxY];
               }
          }
          return nest;
      };
  } (jQuery));
  /* scale.js: resize and zoom functionality
     requires areacorners.js, when.js
  */
  
  
  (function ($) {
      var m = $.mapster, u = m.utils, p = m.MapArea.prototype;
  
      m.utils.getScaleInfo = function (eff, actual) {
          var pct;
          if (!actual) {
              pct = 1;
              actual=eff;
          } else {
              pct = eff.width / actual.width || eff.height / actual.height;
              // make sure a float error doesn't muck us up
              if (pct > 0.98 && pct < 1.02) { pct = 1; }
          }
          return {
              scale: (pct !== 1),
              scalePct: pct,
              realWidth: actual.width,
              realHeight: actual.height,
              width: eff.width,
              height: eff.height,
              ratio: eff.width / eff.height
          };
      };
      // Scale a set of AREAs, return old data as an array of objects
      m.utils.scaleMap = function (image, imageRaw, scale) {
          
          // stunningly, jQuery width can return zero even as width does not, seems to happen only
          // with adBlock or maybe other plugins. These must interfere with onload events somehow.
  
  
          var vis=u.size(image),
              raw=u.size(imageRaw,true);
  
          if (!raw.complete()) {
              throw("Another script, such as an extension, appears to be interfering with image loading. Please let us know about this.");
          }
          if (!vis.complete()) {
              vis=raw;
          }
          return this.getScaleInfo(vis, scale ? raw : null);
      };
      
      /**
       * Resize the image map. Only one of newWidth and newHeight should be passed to preserve scale
       * 
       * @param  {int}   width       The new width OR an object containing named parameters matching this function sig
       * @param  {int}   height      The new height
       * @param  {int}   effectDuration Time in ms for the resize animation, or zero for no animation
       * @param  {function} callback    A function to invoke when the operation finishes
       * @return {promise}              NOT YET IMPLEMENTED
       */
      
      m.MapData.prototype.resize = function (width, height, duration, callback) {
          var p,promises,newsize,els, highlightId, ratio, 
              me = this;
          
          // allow omitting duration
          callback = callback || duration;
  
          function sizeCanvas(canvas, w, h) {
              if (m.hasCanvas()) {
                  canvas.width = w;
                  canvas.height = h;
              } else {
                  $(canvas).width(w);
                  $(canvas).height(h);
              }
          }
  
          // Finalize resize action, do callback, pass control to command queue
  
          function cleanupAndNotify() {
  
              me.currentAction = '';
              
              if ($.isFunction(callback)) {
                  callback();
              }
              
              me.processCommandQueue();
          }
  
          // handle cleanup after the inner elements are resized
          
          function finishResize() {
              sizeCanvas(me.overlay_canvas, width, height);
  
              // restore highlight state if it was highlighted before
              if (highlightId >= 0) {
                  var areaData = me.data[highlightId];
                  areaData.tempOptions = { fade: false };
                  me.getDataForKey(areaData.key).highlight();
                  areaData.tempOptions = null;
              }
              sizeCanvas(me.base_canvas, width, height);
              me.redrawSelections();
              cleanupAndNotify();
          }
  
          function resizeMapData() {
              $(me.image).css(newsize);
              // start calculation at the same time as effect
              me.scaleInfo = u.getScaleInfo({
                      width: width,
                      height: height
                  },
                  { 
                      width: me.scaleInfo.realWidth,
                      height: me.scaleInfo.realHeight
                  });
              $.each(me.data, function (i, e) {
                  $.each(e.areas(), function (i, e) {
                      e.resize();
                  });
              });
          }
  
          if (me.scaleInfo.width === width && me.scaleInfo.height === height) {
              return;
          }
  
          highlightId = me.highlightId;
  
          
          if (!width) {
              ratio = height / me.scaleInfo.realHeight;
              width = Math.round(me.scaleInfo.realWidth * ratio);
          }
          if (!height) {
              ratio = width / me.scaleInfo.realWidth;
              height = Math.round(me.scaleInfo.realHeight * ratio);
          }
  
          newsize = { 'width': String(width) + 'px', 'height': String(height) + 'px' };
          if (!m.hasCanvas()) {
              $(me.base_canvas).children().remove();
          }
  
          // resize all the elements that are part of the map except the image itself (which is not visible)
          // but including the div wrapper
          els = $(me.wrapper).find('.mapster_el').add(me.wrapper);
  
          if (duration) {
              promises = [];
              me.currentAction = 'resizing';
              els.each(function (i, e) {
                  p = u.defer();
                  promises.push(p);
  
                  $(e).animate(newsize, {
                      duration: duration,
                      complete: p.resolve,
                      easing: "linear"
                  });
              });
  
              p = u.defer();
              promises.push(p);
  
              // though resizeMapData is not async, it needs to be finished just the same as the animations,
              // so add it to the "to do" list.
              
              u.when.all(promises).then(finishResize);
              resizeMapData();
              p.resolve();
          } else {
              els.css(newsize);
              resizeMapData();
              finishResize();
              
          }
      };
  
  
      m.MapArea = u.subclass(m.MapArea, function () {
          //change the area tag data if needed
          this.base.init();
          if (this.owner.scaleInfo.scale) {
              this.resize();
          }
      });
  
      p.coords = function (percent, coordOffset) {
          var j, newCoords = [],
                      pct = percent || this.owner.scaleInfo.scalePct,
                      offset = coordOffset || 0;
  
          if (pct === 1 && coordOffset === 0) {
              return this.originalCoords;
          }
  
          for (j = 0; j < this.length; j++) {
              //amount = j % 2 === 0 ? xPct : yPct;
              newCoords.push(Math.round(this.originalCoords[j] * pct) + offset);
          }
          return newCoords;
      };
      p.resize = function () {
          this.area.coords = this.coords().join(',');
      };
  
      p.reset = function () {
          this.area.coords = this.coords(1).join(',');
      };
      
      m.impl.resize = function (width, height, duration, callback) {
          if (!width && !height) {
              return false;
          }
          var x= (new m.Method(this,
                  function () {
                      this.resize(width, height, duration, callback);
                  },
                  null,
                  {
                      name: 'resize',
                      args: arguments
                  }
              )).go();
          return x;
      };
  
  /*
      m.impl.zoom = function (key, opts) {
          var options = opts || {};
  
          function zoom(areaData) {
              // this will be MapData object returned by Method
  
              var scroll, corners, height, width, ratio,
                      diffX, diffY, ratioX, ratioY, offsetX, offsetY, newWidth, newHeight, scrollLeft, scrollTop,
                      padding = options.padding || 0,
                      scrollBarSize = areaData ? 20 : 0,
                      me = this,
                      zoomOut = false;
  
              if (areaData) {
                  // save original state on first zoom operation
                  if (!me.zoomed) {
                      me.zoomed = true;
                      me.preZoomWidth = me.scaleInfo.width;
                      me.preZoomHeight = me.scaleInfo.height;
                      me.zoomedArea = areaData;
                      if (options.scroll) {
                          me.wrapper.css({ overflow: 'auto' });
                      }
                  }
                  corners = $.mapster.utils.areaCorners(areaData.coords(1, 0));
                  width = me.wrapper.innerWidth() - scrollBarSize - padding * 2;
                  height = me.wrapper.innerHeight() - scrollBarSize - padding * 2;
                  diffX = corners.maxX - corners.minX;
                  diffY = corners.maxY - corners.minY;
                  ratioX = width / diffX;
                  ratioY = height / diffY;
                  ratio = Math.min(ratioX, ratioY);
                  offsetX = (width - diffX * ratio) / 2;
                  offsetY = (height - diffY * ratio) / 2;
  
                  newWidth = me.scaleInfo.realWidth * ratio;
                  newHeight = me.scaleInfo.realHeight * ratio;
                  scrollLeft = (corners.minX) * ratio - padding - offsetX;
                  scrollTop = (corners.minY) * ratio - padding - offsetY;
              } else {
                  if (!me.zoomed) {
                      return;
                  }
                  zoomOut = true;
                  newWidth = me.preZoomWidth;
                  newHeight = me.preZoomHeight;
                  scrollLeft = null;
                  scrollTop = null;
              }
  
              this.resize({
                  width: newWidth,
                  height: newHeight,
                  duration: options.duration,
                  scroll: scroll,
                  scrollLeft: scrollLeft,
                  scrollTop: scrollTop,
                  // closure so we can be sure values are correct
                  callback: (function () {
                      var isZoomOut = zoomOut,
                              scroll = options.scroll,
                              areaD = areaData;
                      return function () {
                          if (isZoomOut) {
                              me.preZoomWidth = null;
                              me.preZoomHeight = null;
                              me.zoomed = false;
                              me.zoomedArea = false;
                              if (scroll) {
                                  me.wrapper.css({ overflow: 'inherit' });
                              }
                          } else {
                              // just to be sure it wasn't canceled & restarted
                              me.zoomedArea = areaD;
                          }
                      };
                  } ())
              });
          }
          return (new m.Method(this,
                  function (opts) {
                      zoom.call(this);
                  },
                  function () {
                      zoom.call(this.owner, this);
                  },
                  {
                      name: 'zoom',
                      args: arguments,
                      first: true,
                      key: key
                  }
                  )).go();
  
  
      };
      */
  } (jQuery));
  /* tooltip.js - tooltip functionality
     requires areacorners.js
  */
  
  (function ($) {
  
      var m = $.mapster, u = m.utils;
      
      $.extend(m.defaults, {
          toolTipContainer: '<div style="border: 2px solid black; background: #EEEEEE; width:160px; padding:4px; margin: 4px; -moz-box-shadow: 3px 3px 5px #535353; ' +
          '-webkit-box-shadow: 3px 3px 5px #535353; box-shadow: 3px 3px 5px #535353; -moz-border-radius: 6px 6px 6px 6px; -webkit-border-radius: 6px; ' +
          'border-radius: 6px 6px 6px 6px; opacity: 0.9;"></dteniv>',
          showToolTip: false,
          toolTipFade: true,
          toolTipClose: ['area-mouseout','image-mouseout'],
          onShowToolTip: null,
          onHideToolTip: null
      });
      
      $.extend(m.area_defaults, {
          toolTip: null,
          toolTipClose: null
      });
      
  
      /**
       * Show a tooltip positioned near this area.
       * 
       * @param {string|jquery} html A string of html or a jQuery object containing the tooltip content.
       * @param {string|jquery} [template] The html template in which to wrap the content
       * @param {string|object} [css] CSS to apply to the outermost element of the tooltip 
       * @return {jquery} The tooltip that was created
       */
      
      function createToolTip(html, template, css) {
          var tooltip;
  
          // wrap the template in a jQuery object, or clone the template if it's already one.
          // This assumes that anything other than a string is a jQuery object; if it's not jQuery will
          // probably throw an error.
          
          if (template) {
              tooltip = typeof template === 'string' ?
                  $(template) : 
                  $(template).clone();
  
              tooltip.append(html);
          } else {
              tooltip=$(html);
          }
  
          // always set display to block, or the positioning css won't work if the end user happened to
          // use a non-block type element.
  
          tooltip.css($.extend((css || {}),{
                  display:"block",
                  position:"absolute"
              })).hide();
          
          $('body').append(tooltip);
  
          // we must actually add the tooltip to the DOM and "show" it in order to figure out how much space it
          // consumes, and then reposition it with that knowledge.
          // We also cache the actual opacity setting to restore finally.
          
          tooltip.attr("data-opacity",tooltip.css("opacity"))
              .css("opacity",0);
          
          // doesn't really show it because opacity=0
          
          return tooltip.show();
      }
  
  
      /**
       * Show a tooltip positioned near this area.
       * 
       * @param {jquery} tooltip The tooltip
       * @param {object} [options] options for displaying the tooltip.
       *  @config {int} [left] The 0-based absolute x position for the tooltip
       *  @config {int} [top] The 0-based absolute y position for the tooltip
       *  @config {string|object} [css] CSS to apply to the outermost element of the tooltip 
       *  @config {bool} [fadeDuration] When non-zero, the duration in milliseconds of a fade-in effect for the tooltip.
       */
      
      function showToolTipImpl(tooltip,options)
      {
          var tooltipCss = { 
                  "left":  options.left + "px",
                  "top": options.top + "px"
              }, 
              actalOpacity=tooltip.attr("data-opacity") || 0,
              zindex = tooltip.css("z-index");
          
          if (parseInt(zindex,10)===0 
              || zindex === "auto") {
              tooltipCss["z-index"] = 9999;
          }
  
          tooltip.css(tooltipCss)
              .addClass('mapster_tooltip');
  
          
          if (options.fadeDuration && options.fadeDuration>0) {
              u.fader(tooltip[0], 0, actalOpacity, options.fadeDuration);
          } else {
              u.setOpacity(tooltip[0], actalOpacity);
          }
      }
        
      /**
       * Hide and remove active tooltips
       * 
       * @param  {MapData} this The mapdata object to which the tooltips belong
       */
      
      m.MapData.prototype.clearToolTip = function() {
          if (this.activeToolTip) {
              this.activeToolTip.stop().remove();
              this.activeToolTip = null;
              this.activeToolTipID = null;
              u.ifFunction(this.options.onHideToolTip, this);
          }
      };
  
      /**
       * Configure the binding between a named tooltip closing option, and a mouse event.
       *
       * If a callback is passed, it will be called when the activating event occurs, and the tooltip will
       * only closed if it returns true.
       *
       * @param  {MapData}  [this]     The MapData object to which this tooltip belongs.
       * @param  {String}   option     The name of the tooltip closing option
       * @param  {String}   event      UI event to bind to this option
       * @param  {Element}  target     The DOM element that is the target of the event
       * @param  {Function} [beforeClose] Callback when the tooltip is closed
       * @param  {Function} [onClose]  Callback when the tooltip is closed
       */
      function bindToolTipClose(options, bindOption, event, target, beforeClose, onClose) {
          var event_name = event + '.mapster-tooltip';
          
          if ($.inArray(bindOption, options) >= 0) {
              target.unbind(event_name)
                  .bind(event_name, function (e) {
                      if (!beforeClose || beforeClose.call(this,e)) {
                          target.unbind('.mapster-tooltip');
                          if (onClose) {
                              onClose.call(this);
                          }
                      }
                  });
              
              return {
                  object: target, 
                  event: event_name
              };
          }
      }
      
      /**
       * Show a tooltip.
       *
       * @param {string|jquery}   [tooltip]       A string of html or a jQuery object containing the tooltip content.
       * 
       * @param {string|jquery}   [target]        The target of the tooltip, to be used to determine positioning. If null,
       *                                          absolute position values must be passed with left and top.
       *
       * @param {string|jquery}   [image]         If target is an [area] the image that owns it
       * 
       * @param {string|jquery}   [container]     An element within which the tooltip must be bounded
       *
       *
       * 
       * @param {object|string|jQuery} [options]  options to apply when creating this tooltip - OR -
       *                                          The markup, or a jquery object, containing the data for the tooltip 
       *                                         
       *  @config {string}        [closeEvents]   A string with one or more comma-separated values that determine when the tooltip
       *                                          closes: 'area-click','tooltip-click','image-mouseout' are valid values
       *                                          then no template will be used.
       *  @config {int}           [offsetx]       the horizontal amount to offset the tooltip 
       *  @config {int}           [offsety]       the vertical amount to offset the tooltip 
       *  @config {string|object} [css]           CSS to apply to the outermost element of the tooltip 
       */
      
      function showToolTip(tooltip,target,image,container,options) {
          var corners,
              ttopts = {};
      
          options = options || {};
  
  
          if (target) {
  
              corners = u.areaCorners(target,image,container,
                                      tooltip.outerWidth(true),
                                      tooltip.outerHeight(true));
  
              // Try to upper-left align it first, if that doesn't work, change the parameters
  
              ttopts.left = corners[0];
              ttopts.top = corners[1];
  
          } else {
              
              ttopts.left = options.left;
              ttopts.top = options.top;
          }
  
          ttopts.left += (options.offsetx || 0);
          ttopts.top +=(options.offsety || 0);
  
          ttopts.css= options.css;
          ttopts.fadeDuration = options.fadeDuration;
  
          showToolTipImpl(tooltip,ttopts);
  
          return tooltip;
      }
      
      /**
       * Show a tooltip positioned near this area.
        *
       * @param {string|jquery}   [content]       A string of html or a jQuery object containing the tooltip content.
       
       * @param {object|string|jQuery} [options]  options to apply when creating this tooltip - OR -
       *                                          The markup, or a jquery object, containing the data for the tooltip 
       *  @config {string|jquery}   [container]     An element within which the tooltip must be bounded
       *  @config {bool}          [template]      a template to use instead of the default. If this property exists and is null,
       *                                          then no template will be used.
       *  @config {string}        [closeEvents]   A string with one or more comma-separated values that determine when the tooltip
       *                                          closes: 'area-click','tooltip-click','image-mouseout' are valid values
       *                                          then no template will be used.
       *  @config {int}           [offsetx]       the horizontal amount to offset the tooltip 
       *  @config {int}           [offsety]       the vertical amount to offset the tooltip 
       *  @config {string|object} [css]           CSS to apply to the outermost element of the tooltip 
       */
      m.AreaData.prototype.showToolTip= function(content,options) {
          var tooltip, closeOpts, target, tipClosed, template,
              ttopts = {},
              ad=this,
              md=ad.owner,
              areaOpts = ad.effectiveOptions();
      
          // copy the options object so we can update it
          options = options ? $.extend({},options) : {};
  
          content = content || areaOpts.toolTip;
          closeOpts = options.closeEvents || areaOpts.toolTipClose || md.options.toolTipClose || 'tooltip-click';
          
          template = typeof options.template !== 'undefined' ? 
                  options.template :
                  md.options.toolTipContainer;
  
          options.closeEvents = typeof closeOpts === 'string' ?
              closeOpts = u.split(closeOpts) :
              closeOpts;
  
          options.fadeDuration = options.fadeDuration ||
                   (md.options.toolTipFade ? 
                      (md.options.fadeDuration || areaOpts.fadeDuration) : 0);
  
          target = ad.area ? 
              ad.area :
              $.map(ad.areas(),
                  function(e) {
                      return e.area;
                  });
  
          if (md.activeToolTipID===ad.areaId) {
              return;
          }
  
          md.clearToolTip();
  
          md.activeToolTip = tooltip = createToolTip(content,
              template,
              options.css);
  
          md.activeToolTipID = ad.areaId;
  
          tipClosed = function() {
              md.clearToolTip();
          };
  
          bindToolTipClose(closeOpts,'area-click', 'click', $(md.map), null, tipClosed);
          bindToolTipClose(closeOpts,'tooltip-click', 'click', tooltip,null, tipClosed);
          bindToolTipClose(closeOpts,'image-mouseout', 'mouseout', $(md.image), function(e) {
              return (e.relatedTarget && e.relatedTarget.nodeName!=='AREA' && e.relatedTarget!==ad.area);
          }, tipClosed);
  
  
          showToolTip(tooltip,
                      target,
                      md.image,
                      options.container,
                      template,
                      options);
  
          u.ifFunction(md.options.onShowToolTip, ad.area,
          {
              toolTip: tooltip,
              options: ttopts,
              areaOptions: areaOpts,
              key: ad.key,
              selected: ad.isSelected()
          });
  
          return tooltip;
      };
      
  
      /**
       * Parse an object that could be a string, a jquery object, or an object with a "contents" property
       * containing html or a jQuery object.
       * 
       * @param  {object|string|jQuery} options The parameter to parse
       * @return {string|jquery} A string or jquery object
       */
      function getHtmlFromOptions(options) {
  
              // see if any html was passed as either the options object itself, or the content property
  
              return (options ?
                  ((typeof options === 'string' || options.jquery) ?
                      options :
                      options.content) :
                  null);
      }
  
      /**
       * Activate or remove a tooltip for an area. When this method is called on an area, the
       * key parameter doesn't apply and "options" is the first parameter.
       *
       * When called with no parameters, or "key" is a falsy value, any active tooltip is cleared.
       * 
       * When only a key is provided, the default tooltip for the area is used. 
       * 
       * When html is provided, this is used instead of the default tooltip.
       * 
       * When "noTemplate" is true, the default tooltip template will not be used either, meaning only
       * the actual html passed will be used.
       *  
       * @param  {string|AreaElement} key The area for which to activate a tooltip, or a DOM element.
       * 
       * @param {object|string|jquery} [options] options to apply when creating this tooltip - OR -
       *                                         The markup, or a jquery object, containing the data for the tooltip 
       *  @config {string|jQuery} [content]   the inner content of the tooltip; the tooltip text or HTML
       *  @config {Element|jQuery} [container]   the inner content of the tooltip; the tooltip text or HTML
       *  @config {bool}          [template]  a template to use instead of the default. If this property exists and is null,
       *                                      then no template will be used.
       *  @config {int}           [offsetx]   the horizontal amount to offset the tooltip.
       *  @config {int}           [offsety]   the vertical amount to offset the tooltip.
       *  @config {string|object} [css]       CSS to apply to the outermost element of the tooltip 
       *  @config {string|object} [css] CSS to apply to the outermost element of the tooltip 
       *  @config {bool}          [fadeDuration] When non-zero, the duration in milliseconds of a fade-in effect for the tooltip.
       * @return {jQuery} The jQuery object
       */
      
      m.impl.tooltip = function (key,options) {
          return (new m.Method(this,
          function mapData() {
              var tooltip, target, md=this;
              if (!key) {
                  md.clearToolTip();
              } else {
                  target=$(key);
                  if (md.activeToolTipID ===target[0]) {
                      return;
                  }
                  md.clearToolTip();
  
                  md.activeToolTip = tooltip = createToolTip(getHtmlFromOptions(options),
                              options.template || md.options.toolTipContainer,
                              options.css);
                  md.activeToolTipID = target[0];
  
                  bindToolTipClose(['tooltip-click'],'tooltip-click', 'click', tooltip, null, function() {
                      md.clearToolTip();
                  });
  
                  md.activeToolTip = tooltip = showToolTip(tooltip,
                      target,
                      md.image,
                      options.container,
                      options);
              }
          },
          function areaData() {
              if ($.isPlainObject(key) && !options) {
                  options = key;
              }
  
              this.showToolTip(getHtmlFromOptions(options),options);
          },
          { 
              name: 'tooltip',
              args: arguments,
              key: key
          }
      )).go();
      };
  } (jQuery));
  