@oliasoft-open-source/charts-library 4.8.2 → 4.8.3-beta-1

package/dist/index.js

@@ -572,9 +572,9 @@ let Color$1 = class Color {
   }
 };
 /*!
- * Chart.js v4.4.7
+ * Chart.js v4.4.8
  * https://www.chartjs.org
- * (c) 2024 Chart.js Contributors
+ * (c) 2025 Chart.js Contributors
  * Released under the MIT License
  */
 function noop$1() {
@@ -815,8 +815,11 @@ function _factorize$1(value) {
   result.sort((a2, b2) => a2 - b2).pop();
   return result;
 }
+function isNonPrimitive(n2) {
+  return typeof n2 === "symbol" || typeof n2 === "object" && n2 !== null && !(Symbol.toPrimitive in n2 || "toString" in n2 || "valueOf" in n2);
+}
 function isNumber$1(n2) {
-  return !isNaN(parseFloat(n2)) && isFinite(n2);
+  return !isNonPrimitive(n2) && !isNaN(parseFloat(n2)) && isFinite(n2);
 }
 function almostWhole$1(x2, epsilon) {
   const rounded = Math.round(x2);
@@ -1034,24 +1037,35 @@ function _getStartAndCountOfVisiblePoints$1(meta, points, animationsDisabled) {
   let start = 0;
   let count = pointCount;
   if (meta._sorted) {
-    const { iScale, _parsed } = meta;
+    const { iScale, vScale, _parsed } = meta;
+    const spanGaps = meta.dataset ? meta.dataset.options ? meta.dataset.options.spanGaps : null : null;
     const axis = iScale.axis;
     const { min, max, minDefined, maxDefined } = iScale.getUserBounds();
     if (minDefined) {
-      start = _limitValue$1(Math.min(
+      start = Math.min(
         // @ts-expect-error Need to type _parsed
         _lookupByKey$1(_parsed, axis, min).lo,
         // @ts-expect-error Need to fix types on _lookupByKey
         animationsDisabled ? pointCount : _lookupByKey$1(points, axis, iScale.getPixelForValue(min)).lo
-      ), 0, pointCount - 1);
+      );
+      if (spanGaps) {
+        const distanceToDefinedLo = _parsed.slice(0, start + 1).reverse().findIndex((point) => !isNullOrUndef$1(point[vScale.axis]));
+        start -= Math.max(0, distanceToDefinedLo);
+      }
+      start = _limitValue$1(start, 0, pointCount - 1);
     }
     if (maxDefined) {
-      count = _limitValue$1(Math.max(
+      let end = Math.max(
         // @ts-expect-error Need to type _parsed
         _lookupByKey$1(_parsed, iScale.axis, max, true).hi + 1,
         // @ts-expect-error Need to fix types on _lookupByKey
         animationsDisabled ? 0 : _lookupByKey$1(points, axis, iScale.getPixelForValue(max), true).hi + 1
-      ), start, pointCount) - start;
+      );
+      if (spanGaps) {
+        const distanceToDefinedHi = _parsed.slice(end - 1).findIndex((point) => !isNullOrUndef$1(point[vScale.axis]));
+        end += Math.max(0, distanceToDefinedHi);
+      }
+      count = _limitValue$1(end, start, pointCount) - start;
     } else {
       count = pointCount - start;
     }
@@ -1562,6 +1576,7 @@ function drawPointLegend$1(ctx, options, x2, y2, w2) {
   }
   ctx.beginPath();
   switch (style) {
+    // Default includes circle
     default:
       if (w2) {
         ctx.ellipse(x2, y2, w2 / 2, radius, 0, 0, TAU$1);
@@ -1600,6 +1615,7 @@ function drawPointLegend$1(ctx, options, x2, y2, w2) {
         break;
       }
       rad += QUARTER_PI$1;
+    /* falls through */
     case "rectRot":
       xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
       xOffset = Math.cos(rad) * radius;
@@ -1613,6 +1629,7 @@ function drawPointLegend$1(ctx, options, x2, y2, w2) {
       break;
     case "crossRot":
       rad += QUARTER_PI$1;
+    /* falls through */
     case "cross":
       xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
       xOffset = Math.cos(rad) * radius;
@@ -2883,9 +2900,9 @@ function styleChanged$1(style, prevStyle) {
   return JSON.stringify(style, replacer) !== JSON.stringify(prevStyle, replacer);
 }
 /*!
- * Chart.js v4.4.7
+ * Chart.js v4.4.8
  * https://www.chartjs.org
- * (c) 2024 Chart.js Contributors
+ * (c) 2025 Chart.js Contributors
  * Released under the MIT License
  */
 let Animator$1 = class Animator {
@@ -5094,10 +5111,20 @@ var adapters$1 = {
 function binarySearch$1(metaset, axis, value, intersect) {
   const { controller, data, _sorted } = metaset;
   const iScale = controller._cachedMeta.iScale;
+  const spanGaps = metaset.dataset ? metaset.dataset.options ? metaset.dataset.options.spanGaps : null : null;
   if (iScale && axis === iScale.axis && axis !== "r" && _sorted && data.length) {
     const lookupMethod = iScale._reversePixels ? _rlookupByKey$1 : _lookupByKey$1;
     if (!intersect) {
-      return lookupMethod(data, axis, value);
+      const result = lookupMethod(data, axis, value);
+      if (spanGaps) {
+        const { vScale } = controller._cachedMeta;
+        const { _parsed } = metaset;
+        const distanceToDefinedLo = _parsed.slice(0, result.lo + 1).reverse().findIndex((point) => !isNullOrUndef$1(point[vScale.axis]));
+        result.lo -= Math.max(0, distanceToDefinedLo);
+        const distanceToDefinedHi = _parsed.slice(result.hi).findIndex((point) => !isNullOrUndef$1(point[vScale.axis]));
+        result.hi += Math.max(0, distanceToDefinedHi);
+      }
+      return result;
     } else if (controller._sharedOptions) {
       const el = data[0];
       const range = typeof el.getRange === "function" && el.getRange(axis);
@@ -7975,7 +8002,7 @@ function needContext$1(proxy, names2) {
   }
   return false;
 }
-var version$3 = "4.4.7";
+var version$3 = "4.4.8";
 const KNOWN_POSITIONS$1 = [
   "top",
   "bottom",
@@ -13133,1797 +13160,1803 @@ var hammer = { exports: {} };
  *
  * Copyright (c) 2016 Jorik Tangelder;
  * Licensed under the MIT license */
-(function(module) {
-  (function(window2, document2, exportName, undefined$1) {
-    var VENDOR_PREFIXES = ["", "webkit", "Moz", "MS", "ms", "o"];
-    var TEST_ELEMENT = document2.createElement("div");
-    var TYPE_FUNCTION = "function";
-    var round2 = Math.round;
-    var abs = Math.abs;
-    var now = Date.now;
-    function setTimeoutContext(fn, timeout, context) {
-      return setTimeout(bindFn(fn, context), timeout);
-    }
-    function invokeArrayArg(arg, fn, context) {
-      if (Array.isArray(arg)) {
-        each2(arg, context[fn], context);
-        return true;
-      }
-      return false;
-    }
-    function each2(obj, iterator, context) {
-      var i2;
-      if (!obj) {
-        return;
-      }
-      if (obj.forEach) {
-        obj.forEach(iterator, context);
-      } else if (obj.length !== undefined$1) {
-        i2 = 0;
-        while (i2 < obj.length) {
-          iterator.call(context, obj[i2], i2, obj);
-          i2++;
-        }
-      } else {
-        for (i2 in obj) {
-          obj.hasOwnProperty(i2) && iterator.call(context, obj[i2], i2, obj);
+var hasRequiredHammer;
+function requireHammer() {
+  if (hasRequiredHammer) return hammer.exports;
+  hasRequiredHammer = 1;
+  (function(module) {
+    (function(window2, document2, exportName, undefined$1) {
+      var VENDOR_PREFIXES = ["", "webkit", "Moz", "MS", "ms", "o"];
+      var TEST_ELEMENT = document2.createElement("div");
+      var TYPE_FUNCTION = "function";
+      var round2 = Math.round;
+      var abs = Math.abs;
+      var now = Date.now;
+      function setTimeoutContext(fn, timeout, context) {
+        return setTimeout(bindFn(fn, context), timeout);
+      }
+      function invokeArrayArg(arg, fn, context) {
+        if (Array.isArray(arg)) {
+          each2(arg, context[fn], context);
+          return true;
         }
+        return false;
       }
-    }
-    function deprecate(method, name, message) {
-      var deprecationMessage = "DEPRECATED METHOD: " + name + "\n" + message + " AT \n";
-      return function() {
-        var e2 = new Error("get-stack-trace");
-        var stack = e2 && e2.stack ? e2.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.<anonymous>\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace";
-        var log = window2.console && (window2.console.warn || window2.console.log);
-        if (log) {
-          log.call(window2.console, deprecationMessage, stack);
-        }
-        return method.apply(this, arguments);
-      };
-    }
-    var assign;
-    if (typeof Object.assign !== "function") {
-      assign = function assign2(target) {
-        if (target === undefined$1 || target === null) {
-          throw new TypeError("Cannot convert undefined or null to object");
+      function each2(obj, iterator, context) {
+        var i2;
+        if (!obj) {
+          return;
         }
-        var output = Object(target);
-        for (var index2 = 1; index2 < arguments.length; index2++) {
-          var source = arguments[index2];
-          if (source !== undefined$1 && source !== null) {
-            for (var nextKey in source) {
-              if (source.hasOwnProperty(nextKey)) {
-                output[nextKey] = source[nextKey];
-              }
-            }
+        if (obj.forEach) {
+          obj.forEach(iterator, context);
+        } else if (obj.length !== undefined$1) {
+          i2 = 0;
+          while (i2 < obj.length) {
+            iterator.call(context, obj[i2], i2, obj);
+            i2++;
+          }
+        } else {
+          for (i2 in obj) {
+            obj.hasOwnProperty(i2) && iterator.call(context, obj[i2], i2, obj);
           }
         }
-        return output;
-      };
-    } else {
-      assign = Object.assign;
-    }
-    var extend = deprecate(function extend2(dest, src, merge3) {
-      var keys = Object.keys(src);
-      var i2 = 0;
-      while (i2 < keys.length) {
-        if (!merge3 || merge3 && dest[keys[i2]] === undefined$1) {
-          dest[keys[i2]] = src[keys[i2]];
-        }
-        i2++;
-      }
-      return dest;
-    }, "extend", "Use `assign`.");
-    var merge2 = deprecate(function merge3(dest, src) {
-      return extend(dest, src, true);
-    }, "merge", "Use `assign`.");
-    function inherit(child, base, properties) {
-      var baseP = base.prototype, childP;
-      childP = child.prototype = Object.create(baseP);
-      childP.constructor = child;
-      childP._super = baseP;
-      if (properties) {
-        assign(childP, properties);
-      }
-    }
-    function bindFn(fn, context) {
-      return function boundFn() {
-        return fn.apply(context, arguments);
-      };
-    }
-    function boolOrFn(val, args) {
-      if (typeof val == TYPE_FUNCTION) {
-        return val.apply(args ? args[0] || undefined$1 : undefined$1, args);
       }
-      return val;
-    }
-    function ifUndefined(val1, val2) {
-      return val1 === undefined$1 ? val2 : val1;
-    }
-    function addEventListeners(target, types, handler) {
-      each2(splitStr(types), function(type) {
-        target.addEventListener(type, handler, false);
-      });
-    }
-    function removeEventListeners(target, types, handler) {
-      each2(splitStr(types), function(type) {
-        target.removeEventListener(type, handler, false);
-      });
-    }
-    function hasParent(node, parent) {
-      while (node) {
-        if (node == parent) {
-          return true;
-        }
-        node = node.parentNode;
+      function deprecate(method, name, message) {
+        var deprecationMessage = "DEPRECATED METHOD: " + name + "\n" + message + " AT \n";
+        return function() {
+          var e2 = new Error("get-stack-trace");
+          var stack = e2 && e2.stack ? e2.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.<anonymous>\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace";
+          var log = window2.console && (window2.console.warn || window2.console.log);
+          if (log) {
+            log.call(window2.console, deprecationMessage, stack);
+          }
+          return method.apply(this, arguments);
+        };
       }
-      return false;
-    }
-    function inStr(str, find2) {
-      return str.indexOf(find2) > -1;
-    }
-    function splitStr(str) {
-      return str.trim().split(/\s+/g);
-    }
-    function inArray(src, find2, findByKey) {
-      if (src.indexOf && !findByKey) {
-        return src.indexOf(find2);
+      var assign;
+      if (typeof Object.assign !== "function") {
+        assign = function assign2(target) {
+          if (target === undefined$1 || target === null) {
+            throw new TypeError("Cannot convert undefined or null to object");
+          }
+          var output = Object(target);
+          for (var index2 = 1; index2 < arguments.length; index2++) {
+            var source = arguments[index2];
+            if (source !== undefined$1 && source !== null) {
+              for (var nextKey in source) {
+                if (source.hasOwnProperty(nextKey)) {
+                  output[nextKey] = source[nextKey];
+                }
+              }
+            }
+          }
+          return output;
+        };
       } else {
+        assign = Object.assign;
+      }
+      var extend = deprecate(function extend2(dest, src, merge3) {
+        var keys = Object.keys(src);
         var i2 = 0;
-        while (i2 < src.length) {
-          if (findByKey && src[i2][findByKey] == find2 || !findByKey && src[i2] === find2) {
-            return i2;
+        while (i2 < keys.length) {
+          if (!merge3 || merge3 && dest[keys[i2]] === undefined$1) {
+            dest[keys[i2]] = src[keys[i2]];
           }
           i2++;
         }
-        return -1;
-      }
-    }
-    function toArray2(obj) {
-      return Array.prototype.slice.call(obj, 0);
-    }
-    function uniqueArray(src, key, sort) {
-      var results = [];
-      var values = [];
-      var i2 = 0;
-      while (i2 < src.length) {
-        var val = src[i2][key];
-        if (inArray(values, val) < 0) {
-          results.push(src[i2]);
+        return dest;
+      }, "extend", "Use `assign`.");
+      var merge2 = deprecate(function merge3(dest, src) {
+        return extend(dest, src, true);
+      }, "merge", "Use `assign`.");
+      function inherit(child, base, properties) {
+        var baseP = base.prototype, childP;
+        childP = child.prototype = Object.create(baseP);
+        childP.constructor = child;
+        childP._super = baseP;
+        if (properties) {
+          assign(childP, properties);
         }
-        values[i2] = val;
-        i2++;
       }
-      {
-        {
-          results = results.sort(function sortUniqueArray(a2, b2) {
-            return a2[key] > b2[key];
-          });
-        }
+      function bindFn(fn, context) {
+        return function boundFn() {
+          return fn.apply(context, arguments);
+        };
       }
-      return results;
-    }
-    function prefixed(obj, property) {
-      var prefix, prop;
-      var camelProp = property[0].toUpperCase() + property.slice(1);
-      var i2 = 0;
-      while (i2 < VENDOR_PREFIXES.length) {
-        prefix = VENDOR_PREFIXES[i2];
-        prop = prefix ? prefix + camelProp : property;
-        if (prop in obj) {
-          return prop;
+      function boolOrFn(val, args) {
+        if (typeof val == TYPE_FUNCTION) {
+          return val.apply(args ? args[0] || undefined$1 : undefined$1, args);
         }
-        i2++;
-      }
-      return undefined$1;
-    }
-    var _uniqueId = 1;
-    function uniqueId() {
-      return _uniqueId++;
-    }
-    function getWindowForElement(element) {
-      var doc = element.ownerDocument || element;
-      return doc.defaultView || doc.parentWindow || window2;
-    }
-    var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
-    var SUPPORT_TOUCH = "ontouchstart" in window2;
-    var SUPPORT_POINTER_EVENTS = prefixed(window2, "PointerEvent") !== undefined$1;
-    var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
-    var INPUT_TYPE_TOUCH = "touch";
-    var INPUT_TYPE_PEN = "pen";
-    var INPUT_TYPE_MOUSE = "mouse";
-    var INPUT_TYPE_KINECT = "kinect";
-    var COMPUTE_INTERVAL = 25;
-    var INPUT_START = 1;
-    var INPUT_MOVE = 2;
-    var INPUT_END = 4;
-    var INPUT_CANCEL = 8;
-    var DIRECTION_NONE = 1;
-    var DIRECTION_LEFT = 2;
-    var DIRECTION_RIGHT = 4;
-    var DIRECTION_UP = 8;
-    var DIRECTION_DOWN = 16;
-    var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
-    var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
-    var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
-    var PROPS_XY = ["x", "y"];
-    var PROPS_CLIENT_XY = ["clientX", "clientY"];
-    function Input(manager, callback2) {
-      var self2 = this;
-      this.manager = manager;
-      this.callback = callback2;
-      this.element = manager.element;
-      this.target = manager.options.inputTarget;
-      this.domHandler = function(ev) {
-        if (boolOrFn(manager.options.enable, [manager])) {
-          self2.handler(ev);
-        }
-      };
-      this.init();
-    }
-    Input.prototype = {
-      /**
-       * should handle the inputEvent data and trigger the callback
-       * @virtual
-       */
-      handler: function() {
-      },
-      /**
-       * bind the events
-       */
-      init: function() {
-        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
-        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
-        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
-      },
-      /**
-       * unbind the events
-       */
-      destroy: function() {
-        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
-        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
-        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+        return val;
       }
-    };
-    function createInputInstance(manager) {
-      var Type;
-      var inputClass = manager.options.inputClass;
-      if (inputClass) {
-        Type = inputClass;
-      } else if (SUPPORT_POINTER_EVENTS) {
-        Type = PointerEventInput;
-      } else if (SUPPORT_ONLY_TOUCH) {
-        Type = TouchInput;
-      } else if (!SUPPORT_TOUCH) {
-        Type = MouseInput;
-      } else {
-        Type = TouchMouseInput;
-      }
-      return new Type(manager, inputHandler);
-    }
-    function inputHandler(manager, eventType, input) {
-      var pointersLen = input.pointers.length;
-      var changedPointersLen = input.changedPointers.length;
-      var isFirst = eventType & INPUT_START && pointersLen - changedPointersLen === 0;
-      var isFinal = eventType & (INPUT_END | INPUT_CANCEL) && pointersLen - changedPointersLen === 0;
-      input.isFirst = !!isFirst;
-      input.isFinal = !!isFinal;
-      if (isFirst) {
-        manager.session = {};
-      }
-      input.eventType = eventType;
-      computeInputData(manager, input);
-      manager.emit("hammer.input", input);
-      manager.recognize(input);
-      manager.session.prevInput = input;
-    }
-    function computeInputData(manager, input) {
-      var session = manager.session;
-      var pointers = input.pointers;
-      var pointersLength = pointers.length;
-      if (!session.firstInput) {
-        session.firstInput = simpleCloneInputData(input);
-      }
-      if (pointersLength > 1 && !session.firstMultiple) {
-        session.firstMultiple = simpleCloneInputData(input);
-      } else if (pointersLength === 1) {
-        session.firstMultiple = false;
-      }
-      var firstInput = session.firstInput;
-      var firstMultiple = session.firstMultiple;
-      var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
-      var center = input.center = getCenter2(pointers);
-      input.timeStamp = now();
-      input.deltaTime = input.timeStamp - firstInput.timeStamp;
-      input.angle = getAngle(offsetCenter, center);
-      input.distance = getDistance(offsetCenter, center);
-      computeDeltaXY(session, input);
-      input.offsetDirection = getDirection(input.deltaX, input.deltaY);
-      var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
-      input.overallVelocityX = overallVelocity.x;
-      input.overallVelocityY = overallVelocity.y;
-      input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
-      input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
-      input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
-      input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
-      computeIntervalInputData(session, input);
-      var target = manager.element;
-      if (hasParent(input.srcEvent.target, target)) {
-        target = input.srcEvent.target;
-      }
-      input.target = target;
-    }
-    function computeDeltaXY(session, input) {
-      var center = input.center;
-      var offset = session.offsetDelta || {};
-      var prevDelta = session.prevDelta || {};
-      var prevInput = session.prevInput || {};
-      if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
-        prevDelta = session.prevDelta = {
-          x: prevInput.deltaX || 0,
-          y: prevInput.deltaY || 0
-        };
-        offset = session.offsetDelta = {
-          x: center.x,
-          y: center.y
-        };
+      function ifUndefined(val1, val2) {
+        return val1 === undefined$1 ? val2 : val1;
       }
-      input.deltaX = prevDelta.x + (center.x - offset.x);
-      input.deltaY = prevDelta.y + (center.y - offset.y);
-    }
-    function computeIntervalInputData(session, input) {
-      var last = session.lastInterval || input, deltaTime = input.timeStamp - last.timeStamp, velocity, velocityX, velocityY, direction;
-      if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined$1)) {
-        var deltaX = input.deltaX - last.deltaX;
-        var deltaY = input.deltaY - last.deltaY;
-        var v2 = getVelocity(deltaTime, deltaX, deltaY);
-        velocityX = v2.x;
-        velocityY = v2.y;
-        velocity = abs(v2.x) > abs(v2.y) ? v2.x : v2.y;
-        direction = getDirection(deltaX, deltaY);
-        session.lastInterval = input;
-      } else {
-        velocity = last.velocity;
-        velocityX = last.velocityX;
-        velocityY = last.velocityY;
-        direction = last.direction;
-      }
-      input.velocity = velocity;
-      input.velocityX = velocityX;
-      input.velocityY = velocityY;
-      input.direction = direction;
-    }
-    function simpleCloneInputData(input) {
-      var pointers = [];
-      var i2 = 0;
-      while (i2 < input.pointers.length) {
-        pointers[i2] = {
-          clientX: round2(input.pointers[i2].clientX),
-          clientY: round2(input.pointers[i2].clientY)
-        };
-        i2++;
+      function addEventListeners(target, types, handler) {
+        each2(splitStr(types), function(type) {
+          target.addEventListener(type, handler, false);
+        });
       }
-      return {
-        timeStamp: now(),
-        pointers,
-        center: getCenter2(pointers),
-        deltaX: input.deltaX,
-        deltaY: input.deltaY
-      };
-    }
-    function getCenter2(pointers) {
-      var pointersLength = pointers.length;
-      if (pointersLength === 1) {
-        return {
-          x: round2(pointers[0].clientX),
-          y: round2(pointers[0].clientY)
-        };
+      function removeEventListeners(target, types, handler) {
+        each2(splitStr(types), function(type) {
+          target.removeEventListener(type, handler, false);
+        });
       }
-      var x2 = 0, y2 = 0, i2 = 0;
-      while (i2 < pointersLength) {
-        x2 += pointers[i2].clientX;
-        y2 += pointers[i2].clientY;
-        i2++;
+      function hasParent(node, parent) {
+        while (node) {
+          if (node == parent) {
+            return true;
+          }
+          node = node.parentNode;
+        }
+        return false;
       }
-      return {
-        x: round2(x2 / pointersLength),
-        y: round2(y2 / pointersLength)
-      };
-    }
-    function getVelocity(deltaTime, x2, y2) {
-      return {
-        x: x2 / deltaTime || 0,
-        y: y2 / deltaTime || 0
-      };
-    }
-    function getDirection(x2, y2) {
-      if (x2 === y2) {
-        return DIRECTION_NONE;
+      function inStr(str, find2) {
+        return str.indexOf(find2) > -1;
       }
-      if (abs(x2) >= abs(y2)) {
-        return x2 < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
+      function splitStr(str) {
+        return str.trim().split(/\s+/g);
       }
-      return y2 < 0 ? DIRECTION_UP : DIRECTION_DOWN;
-    }
-    function getDistance(p1, p2, props) {
-      if (!props) {
-        props = PROPS_XY;
+      function inArray(src, find2, findByKey) {
+        if (src.indexOf && !findByKey) {
+          return src.indexOf(find2);
+        } else {
+          var i2 = 0;
+          while (i2 < src.length) {
+            if (findByKey && src[i2][findByKey] == find2 || !findByKey && src[i2] === find2) {
+              return i2;
+            }
+            i2++;
+          }
+          return -1;
+        }
       }
-      var x2 = p2[props[0]] - p1[props[0]], y2 = p2[props[1]] - p1[props[1]];
-      return Math.sqrt(x2 * x2 + y2 * y2);
-    }
-    function getAngle(p1, p2, props) {
-      if (!props) {
-        props = PROPS_XY;
+      function toArray2(obj) {
+        return Array.prototype.slice.call(obj, 0);
       }
-      var x2 = p2[props[0]] - p1[props[0]], y2 = p2[props[1]] - p1[props[1]];
-      return Math.atan2(y2, x2) * 180 / Math.PI;
-    }
-    function getRotation(start, end) {
-      return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
-    }
-    function getScale(start, end) {
-      return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
-    }
-    var MOUSE_INPUT_MAP = {
-      mousedown: INPUT_START,
-      mousemove: INPUT_MOVE,
-      mouseup: INPUT_END
-    };
-    var MOUSE_ELEMENT_EVENTS = "mousedown";
-    var MOUSE_WINDOW_EVENTS = "mousemove mouseup";
-    function MouseInput() {
-      this.evEl = MOUSE_ELEMENT_EVENTS;
-      this.evWin = MOUSE_WINDOW_EVENTS;
-      this.pressed = false;
-      Input.apply(this, arguments);
-    }
-    inherit(MouseInput, Input, {
-      /**
-       * handle mouse events
-       * @param {Object} ev
-       */
-      handler: function MEhandler(ev) {
-        var eventType = MOUSE_INPUT_MAP[ev.type];
-        if (eventType & INPUT_START && ev.button === 0) {
-          this.pressed = true;
-        }
-        if (eventType & INPUT_MOVE && ev.which !== 1) {
-          eventType = INPUT_END;
-        }
-        if (!this.pressed) {
-          return;
+      function uniqueArray(src, key, sort) {
+        var results = [];
+        var values = [];
+        var i2 = 0;
+        while (i2 < src.length) {
+          var val = src[i2][key];
+          if (inArray(values, val) < 0) {
+            results.push(src[i2]);
+          }
+          values[i2] = val;
+          i2++;
         }
-        if (eventType & INPUT_END) {
-          this.pressed = false;
+        {
+          {
+            results = results.sort(function sortUniqueArray(a2, b2) {
+              return a2[key] > b2[key];
+            });
+          }
         }
-        this.callback(this.manager, eventType, {
-          pointers: [ev],
-          changedPointers: [ev],
-          pointerType: INPUT_TYPE_MOUSE,
-          srcEvent: ev
-        });
+        return results;
       }
-    });
-    var POINTER_INPUT_MAP = {
-      pointerdown: INPUT_START,
-      pointermove: INPUT_MOVE,
-      pointerup: INPUT_END,
-      pointercancel: INPUT_CANCEL,
-      pointerout: INPUT_CANCEL
-    };
-    var IE10_POINTER_TYPE_ENUM = {
-      2: INPUT_TYPE_TOUCH,
-      3: INPUT_TYPE_PEN,
-      4: INPUT_TYPE_MOUSE,
-      5: INPUT_TYPE_KINECT
-      // see https://twitter.com/jacobrossi/status/480596438489890816
-    };
-    var POINTER_ELEMENT_EVENTS = "pointerdown";
-    var POINTER_WINDOW_EVENTS = "pointermove pointerup pointercancel";
-    if (window2.MSPointerEvent && !window2.PointerEvent) {
-      POINTER_ELEMENT_EVENTS = "MSPointerDown";
-      POINTER_WINDOW_EVENTS = "MSPointerMove MSPointerUp MSPointerCancel";
-    }
-    function PointerEventInput() {
-      this.evEl = POINTER_ELEMENT_EVENTS;
-      this.evWin = POINTER_WINDOW_EVENTS;
-      Input.apply(this, arguments);
-      this.store = this.manager.session.pointerEvents = [];
-    }
-    inherit(PointerEventInput, Input, {
-      /**
-       * handle mouse events
-       * @param {Object} ev
-       */
-      handler: function PEhandler(ev) {
-        var store = this.store;
-        var removePointer = false;
-        var eventTypeNormalized = ev.type.toLowerCase().replace("ms", "");
-        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
-        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
-        var isTouch = pointerType == INPUT_TYPE_TOUCH;
-        var storeIndex = inArray(store, ev.pointerId, "pointerId");
-        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
-          if (storeIndex < 0) {
-            store.push(ev);
-            storeIndex = store.length - 1;
+      function prefixed(obj, property) {
+        var prefix, prop;
+        var camelProp = property[0].toUpperCase() + property.slice(1);
+        var i2 = 0;
+        while (i2 < VENDOR_PREFIXES.length) {
+          prefix = VENDOR_PREFIXES[i2];
+          prop = prefix ? prefix + camelProp : property;
+          if (prop in obj) {
+            return prop;
           }
-        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
-          removePointer = true;
+          i2++;
         }
-        if (storeIndex < 0) {
-          return;
+        return undefined$1;
+      }
+      var _uniqueId = 1;
+      function uniqueId() {
+        return _uniqueId++;
+      }
+      function getWindowForElement(element) {
+        var doc = element.ownerDocument || element;
+        return doc.defaultView || doc.parentWindow || window2;
+      }
+      var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
+      var SUPPORT_TOUCH = "ontouchstart" in window2;
+      var SUPPORT_POINTER_EVENTS = prefixed(window2, "PointerEvent") !== undefined$1;
+      var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
+      var INPUT_TYPE_TOUCH = "touch";
+      var INPUT_TYPE_PEN = "pen";
+      var INPUT_TYPE_MOUSE = "mouse";
+      var INPUT_TYPE_KINECT = "kinect";
+      var COMPUTE_INTERVAL = 25;
+      var INPUT_START = 1;
+      var INPUT_MOVE = 2;
+      var INPUT_END = 4;
+      var INPUT_CANCEL = 8;
+      var DIRECTION_NONE = 1;
+      var DIRECTION_LEFT = 2;
+      var DIRECTION_RIGHT = 4;
+      var DIRECTION_UP = 8;
+      var DIRECTION_DOWN = 16;
+      var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
+      var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
+      var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
+      var PROPS_XY = ["x", "y"];
+      var PROPS_CLIENT_XY = ["clientX", "clientY"];
+      function Input(manager, callback2) {
+        var self2 = this;
+        this.manager = manager;
+        this.callback = callback2;
+        this.element = manager.element;
+        this.target = manager.options.inputTarget;
+        this.domHandler = function(ev) {
+          if (boolOrFn(manager.options.enable, [manager])) {
+            self2.handler(ev);
+          }
+        };
+        this.init();
+      }
+      Input.prototype = {
+        /**
+         * should handle the inputEvent data and trigger the callback
+         * @virtual
+         */
+        handler: function() {
+        },
+        /**
+         * bind the events
+         */
+        init: function() {
+          this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
+          this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
+          this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+        },
+        /**
+         * unbind the events
+         */
+        destroy: function() {
+          this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
+          this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
+          this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
         }
-        store[storeIndex] = ev;
-        this.callback(this.manager, eventType, {
-          pointers: store,
-          changedPointers: [ev],
-          pointerType,
-          srcEvent: ev
-        });
-        if (removePointer) {
-          store.splice(storeIndex, 1);
+      };
+      function createInputInstance(manager) {
+        var Type;
+        var inputClass = manager.options.inputClass;
+        if (inputClass) {
+          Type = inputClass;
+        } else if (SUPPORT_POINTER_EVENTS) {
+          Type = PointerEventInput;
+        } else if (SUPPORT_ONLY_TOUCH) {
+          Type = TouchInput;
+        } else if (!SUPPORT_TOUCH) {
+          Type = MouseInput;
+        } else {
+          Type = TouchMouseInput;
         }
-      }
-    });
-    var SINGLE_TOUCH_INPUT_MAP = {
-      touchstart: INPUT_START,
-      touchmove: INPUT_MOVE,
-      touchend: INPUT_END,
-      touchcancel: INPUT_CANCEL
-    };
-    var SINGLE_TOUCH_TARGET_EVENTS = "touchstart";
-    var SINGLE_TOUCH_WINDOW_EVENTS = "touchstart touchmove touchend touchcancel";
-    function SingleTouchInput() {
-      this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
-      this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
-      this.started = false;
-      Input.apply(this, arguments);
-    }
-    inherit(SingleTouchInput, Input, {
-      handler: function TEhandler(ev) {
-        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
-        if (type === INPUT_START) {
-          this.started = true;
+        return new Type(manager, inputHandler);
+      }
+      function inputHandler(manager, eventType, input) {
+        var pointersLen = input.pointers.length;
+        var changedPointersLen = input.changedPointers.length;
+        var isFirst = eventType & INPUT_START && pointersLen - changedPointersLen === 0;
+        var isFinal = eventType & (INPUT_END | INPUT_CANCEL) && pointersLen - changedPointersLen === 0;
+        input.isFirst = !!isFirst;
+        input.isFinal = !!isFinal;
+        if (isFirst) {
+          manager.session = {};
         }
-        if (!this.started) {
-          return;
+        input.eventType = eventType;
+        computeInputData(manager, input);
+        manager.emit("hammer.input", input);
+        manager.recognize(input);
+        manager.session.prevInput = input;
+      }
+      function computeInputData(manager, input) {
+        var session = manager.session;
+        var pointers = input.pointers;
+        var pointersLength = pointers.length;
+        if (!session.firstInput) {
+          session.firstInput = simpleCloneInputData(input);
         }
-        var touches = normalizeSingleTouches.call(this, ev, type);
-        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
-          this.started = false;
+        if (pointersLength > 1 && !session.firstMultiple) {
+          session.firstMultiple = simpleCloneInputData(input);
+        } else if (pointersLength === 1) {
+          session.firstMultiple = false;
         }
-        this.callback(this.manager, type, {
-          pointers: touches[0],
-          changedPointers: touches[1],
-          pointerType: INPUT_TYPE_TOUCH,
-          srcEvent: ev
-        });
-      }
-    });
-    function normalizeSingleTouches(ev, type) {
-      var all = toArray2(ev.touches);
-      var changed = toArray2(ev.changedTouches);
-      if (type & (INPUT_END | INPUT_CANCEL)) {
-        all = uniqueArray(all.concat(changed), "identifier");
-      }
-      return [all, changed];
-    }
-    var TOUCH_INPUT_MAP = {
-      touchstart: INPUT_START,
-      touchmove: INPUT_MOVE,
-      touchend: INPUT_END,
-      touchcancel: INPUT_CANCEL
-    };
-    var TOUCH_TARGET_EVENTS = "touchstart touchmove touchend touchcancel";
-    function TouchInput() {
-      this.evTarget = TOUCH_TARGET_EVENTS;
-      this.targetIds = {};
-      Input.apply(this, arguments);
-    }
-    inherit(TouchInput, Input, {
-      handler: function MTEhandler(ev) {
-        var type = TOUCH_INPUT_MAP[ev.type];
-        var touches = getTouches.call(this, ev, type);
-        if (!touches) {
-          return;
+        var firstInput = session.firstInput;
+        var firstMultiple = session.firstMultiple;
+        var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
+        var center = input.center = getCenter2(pointers);
+        input.timeStamp = now();
+        input.deltaTime = input.timeStamp - firstInput.timeStamp;
+        input.angle = getAngle(offsetCenter, center);
+        input.distance = getDistance(offsetCenter, center);
+        computeDeltaXY(session, input);
+        input.offsetDirection = getDirection(input.deltaX, input.deltaY);
+        var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
+        input.overallVelocityX = overallVelocity.x;
+        input.overallVelocityY = overallVelocity.y;
+        input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
+        input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
+        input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
+        input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
+        computeIntervalInputData(session, input);
+        var target = manager.element;
+        if (hasParent(input.srcEvent.target, target)) {
+          target = input.srcEvent.target;
         }
-        this.callback(this.manager, type, {
-          pointers: touches[0],
-          changedPointers: touches[1],
-          pointerType: INPUT_TYPE_TOUCH,
-          srcEvent: ev
-        });
+        input.target = target;
+      }
+      function computeDeltaXY(session, input) {
+        var center = input.center;
+        var offset = session.offsetDelta || {};
+        var prevDelta = session.prevDelta || {};
+        var prevInput = session.prevInput || {};
+        if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
+          prevDelta = session.prevDelta = {
+            x: prevInput.deltaX || 0,
+            y: prevInput.deltaY || 0
+          };
+          offset = session.offsetDelta = {
+            x: center.x,
+            y: center.y
+          };
+        }
+        input.deltaX = prevDelta.x + (center.x - offset.x);
+        input.deltaY = prevDelta.y + (center.y - offset.y);
+      }
+      function computeIntervalInputData(session, input) {
+        var last = session.lastInterval || input, deltaTime = input.timeStamp - last.timeStamp, velocity, velocityX, velocityY, direction;
+        if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined$1)) {
+          var deltaX = input.deltaX - last.deltaX;
+          var deltaY = input.deltaY - last.deltaY;
+          var v2 = getVelocity(deltaTime, deltaX, deltaY);
+          velocityX = v2.x;
+          velocityY = v2.y;
+          velocity = abs(v2.x) > abs(v2.y) ? v2.x : v2.y;
+          direction = getDirection(deltaX, deltaY);
+          session.lastInterval = input;
+        } else {
+          velocity = last.velocity;
+          velocityX = last.velocityX;
+          velocityY = last.velocityY;
+          direction = last.direction;
+        }
+        input.velocity = velocity;
+        input.velocityX = velocityX;
+        input.velocityY = velocityY;
+        input.direction = direction;
       }
-    });
-    function getTouches(ev, type) {
-      var allTouches = toArray2(ev.touches);
-      var targetIds = this.targetIds;
-      if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
-        targetIds[allTouches[0].identifier] = true;
-        return [allTouches, allTouches];
-      }
-      var i2, targetTouches, changedTouches = toArray2(ev.changedTouches), changedTargetTouches = [], target = this.target;
-      targetTouches = allTouches.filter(function(touch) {
-        return hasParent(touch.target, target);
-      });
-      if (type === INPUT_START) {
-        i2 = 0;
-        while (i2 < targetTouches.length) {
-          targetIds[targetTouches[i2].identifier] = true;
+      function simpleCloneInputData(input) {
+        var pointers = [];
+        var i2 = 0;
+        while (i2 < input.pointers.length) {
+          pointers[i2] = {
+            clientX: round2(input.pointers[i2].clientX),
+            clientY: round2(input.pointers[i2].clientY)
+          };
           i2++;
         }
+        return {
+          timeStamp: now(),
+          pointers,
+          center: getCenter2(pointers),
+          deltaX: input.deltaX,
+          deltaY: input.deltaY
+        };
       }
-      i2 = 0;
-      while (i2 < changedTouches.length) {
-        if (targetIds[changedTouches[i2].identifier]) {
-          changedTargetTouches.push(changedTouches[i2]);
+      function getCenter2(pointers) {
+        var pointersLength = pointers.length;
+        if (pointersLength === 1) {
+          return {
+            x: round2(pointers[0].clientX),
+            y: round2(pointers[0].clientY)
+          };
         }
-        if (type & (INPUT_END | INPUT_CANCEL)) {
-          delete targetIds[changedTouches[i2].identifier];
+        var x2 = 0, y2 = 0, i2 = 0;
+        while (i2 < pointersLength) {
+          x2 += pointers[i2].clientX;
+          y2 += pointers[i2].clientY;
+          i2++;
         }
-        i2++;
+        return {
+          x: round2(x2 / pointersLength),
+          y: round2(y2 / pointersLength)
+        };
       }
-      if (!changedTargetTouches.length) {
-        return;
+      function getVelocity(deltaTime, x2, y2) {
+        return {
+          x: x2 / deltaTime || 0,
+          y: y2 / deltaTime || 0
+        };
       }
-      return [
-        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
-        uniqueArray(targetTouches.concat(changedTargetTouches), "identifier"),
-        changedTargetTouches
-      ];
-    }
-    var DEDUP_TIMEOUT = 2500;
-    var DEDUP_DISTANCE = 25;
-    function TouchMouseInput() {
-      Input.apply(this, arguments);
-      var handler = bindFn(this.handler, this);
-      this.touch = new TouchInput(this.manager, handler);
-      this.mouse = new MouseInput(this.manager, handler);
-      this.primaryTouch = null;
-      this.lastTouches = [];
-    }
-    inherit(TouchMouseInput, Input, {
-      /**
-       * handle mouse and touch events
-       * @param {Hammer} manager
-       * @param {String} inputEvent
-       * @param {Object} inputData
-       */
-      handler: function TMEhandler(manager, inputEvent, inputData) {
-        var isTouch = inputData.pointerType == INPUT_TYPE_TOUCH, isMouse = inputData.pointerType == INPUT_TYPE_MOUSE;
-        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
-          return;
+      function getDirection(x2, y2) {
+        if (x2 === y2) {
+          return DIRECTION_NONE;
         }
-        if (isTouch) {
-          recordTouches.call(this, inputEvent, inputData);
-        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {
-          return;
+        if (abs(x2) >= abs(y2)) {
+          return x2 < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
         }
-        this.callback(manager, inputEvent, inputData);
-      },
-      /**
-       * remove the event listeners
-       */
-      destroy: function destroy() {
-        this.touch.destroy();
-        this.mouse.destroy();
+        return y2 < 0 ? DIRECTION_UP : DIRECTION_DOWN;
       }
-    });
-    function recordTouches(eventType, eventData) {
-      if (eventType & INPUT_START) {
-        this.primaryTouch = eventData.changedPointers[0].identifier;
-        setLastTouch.call(this, eventData);
-      } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
-        setLastTouch.call(this, eventData);
-      }
-    }
-    function setLastTouch(eventData) {
-      var touch = eventData.changedPointers[0];
-      if (touch.identifier === this.primaryTouch) {
-        var lastTouch = { x: touch.clientX, y: touch.clientY };
-        this.lastTouches.push(lastTouch);
-        var lts = this.lastTouches;
-        var removeLastTouch = function() {
-          var i2 = lts.indexOf(lastTouch);
-          if (i2 > -1) {
-            lts.splice(i2, 1);
-          }
-        };
-        setTimeout(removeLastTouch, DEDUP_TIMEOUT);
+      function getDistance(p1, p2, props) {
+        if (!props) {
+          props = PROPS_XY;
+        }
+        var x2 = p2[props[0]] - p1[props[0]], y2 = p2[props[1]] - p1[props[1]];
+        return Math.sqrt(x2 * x2 + y2 * y2);
       }
-    }
-    function isSyntheticEvent(eventData) {
-      var x2 = eventData.srcEvent.clientX, y2 = eventData.srcEvent.clientY;
-      for (var i2 = 0; i2 < this.lastTouches.length; i2++) {
-        var t = this.lastTouches[i2];
-        var dx = Math.abs(x2 - t.x), dy = Math.abs(y2 - t.y);
-        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
-          return true;
+      function getAngle(p1, p2, props) {
+        if (!props) {
+          props = PROPS_XY;
         }
+        var x2 = p2[props[0]] - p1[props[0]], y2 = p2[props[1]] - p1[props[1]];
+        return Math.atan2(y2, x2) * 180 / Math.PI;
       }
-      return false;
-    }
-    var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, "touchAction");
-    var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined$1;
-    var TOUCH_ACTION_COMPUTE = "compute";
-    var TOUCH_ACTION_AUTO = "auto";
-    var TOUCH_ACTION_MANIPULATION = "manipulation";
-    var TOUCH_ACTION_NONE = "none";
-    var TOUCH_ACTION_PAN_X = "pan-x";
-    var TOUCH_ACTION_PAN_Y = "pan-y";
-    var TOUCH_ACTION_MAP = getTouchActionProps();
-    function TouchAction(manager, value) {
-      this.manager = manager;
-      this.set(value);
-    }
-    TouchAction.prototype = {
-      /**
-       * set the touchAction value on the element or enable the polyfill
-       * @param {String} value
-       */
-      set: function(value) {
-        if (value == TOUCH_ACTION_COMPUTE) {
-          value = this.compute();
+      function getRotation(start, end) {
+        return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
+      }
+      function getScale(start, end) {
+        return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
+      }
+      var MOUSE_INPUT_MAP = {
+        mousedown: INPUT_START,
+        mousemove: INPUT_MOVE,
+        mouseup: INPUT_END
+      };
+      var MOUSE_ELEMENT_EVENTS = "mousedown";
+      var MOUSE_WINDOW_EVENTS = "mousemove mouseup";
+      function MouseInput() {
+        this.evEl = MOUSE_ELEMENT_EVENTS;
+        this.evWin = MOUSE_WINDOW_EVENTS;
+        this.pressed = false;
+        Input.apply(this, arguments);
+      }
+      inherit(MouseInput, Input, {
+        /**
+         * handle mouse events
+         * @param {Object} ev
+         */
+        handler: function MEhandler(ev) {
+          var eventType = MOUSE_INPUT_MAP[ev.type];
+          if (eventType & INPUT_START && ev.button === 0) {
+            this.pressed = true;
+          }
+          if (eventType & INPUT_MOVE && ev.which !== 1) {
+            eventType = INPUT_END;
+          }
+          if (!this.pressed) {
+            return;
+          }
+          if (eventType & INPUT_END) {
+            this.pressed = false;
+          }
+          this.callback(this.manager, eventType, {
+            pointers: [ev],
+            changedPointers: [ev],
+            pointerType: INPUT_TYPE_MOUSE,
+            srcEvent: ev
+          });
         }
-        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
-          this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
+      });
+      var POINTER_INPUT_MAP = {
+        pointerdown: INPUT_START,
+        pointermove: INPUT_MOVE,
+        pointerup: INPUT_END,
+        pointercancel: INPUT_CANCEL,
+        pointerout: INPUT_CANCEL
+      };
+      var IE10_POINTER_TYPE_ENUM = {
+        2: INPUT_TYPE_TOUCH,
+        3: INPUT_TYPE_PEN,
+        4: INPUT_TYPE_MOUSE,
+        5: INPUT_TYPE_KINECT
+        // see https://twitter.com/jacobrossi/status/480596438489890816
+      };
+      var POINTER_ELEMENT_EVENTS = "pointerdown";
+      var POINTER_WINDOW_EVENTS = "pointermove pointerup pointercancel";
+      if (window2.MSPointerEvent && !window2.PointerEvent) {
+        POINTER_ELEMENT_EVENTS = "MSPointerDown";
+        POINTER_WINDOW_EVENTS = "MSPointerMove MSPointerUp MSPointerCancel";
+      }
+      function PointerEventInput() {
+        this.evEl = POINTER_ELEMENT_EVENTS;
+        this.evWin = POINTER_WINDOW_EVENTS;
+        Input.apply(this, arguments);
+        this.store = this.manager.session.pointerEvents = [];
+      }
+      inherit(PointerEventInput, Input, {
+        /**
+         * handle mouse events
+         * @param {Object} ev
+         */
+        handler: function PEhandler(ev) {
+          var store = this.store;
+          var removePointer = false;
+          var eventTypeNormalized = ev.type.toLowerCase().replace("ms", "");
+          var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
+          var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
+          var isTouch = pointerType == INPUT_TYPE_TOUCH;
+          var storeIndex = inArray(store, ev.pointerId, "pointerId");
+          if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
+            if (storeIndex < 0) {
+              store.push(ev);
+              storeIndex = store.length - 1;
+            }
+          } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
+            removePointer = true;
+          }
+          if (storeIndex < 0) {
+            return;
+          }
+          store[storeIndex] = ev;
+          this.callback(this.manager, eventType, {
+            pointers: store,
+            changedPointers: [ev],
+            pointerType,
+            srcEvent: ev
+          });
+          if (removePointer) {
+            store.splice(storeIndex, 1);
+          }
         }
-        this.actions = value.toLowerCase().trim();
-      },
-      /**
-       * just re-set the touchAction value
-       */
-      update: function() {
-        this.set(this.manager.options.touchAction);
-      },
-      /**
-       * compute the value for the touchAction property based on the recognizer's settings
-       * @returns {String} value
-       */
-      compute: function() {
-        var actions2 = [];
-        each2(this.manager.recognizers, function(recognizer) {
-          if (boolOrFn(recognizer.options.enable, [recognizer])) {
-            actions2 = actions2.concat(recognizer.getTouchAction());
+      });
+      var SINGLE_TOUCH_INPUT_MAP = {
+        touchstart: INPUT_START,
+        touchmove: INPUT_MOVE,
+        touchend: INPUT_END,
+        touchcancel: INPUT_CANCEL
+      };
+      var SINGLE_TOUCH_TARGET_EVENTS = "touchstart";
+      var SINGLE_TOUCH_WINDOW_EVENTS = "touchstart touchmove touchend touchcancel";
+      function SingleTouchInput() {
+        this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
+        this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
+        this.started = false;
+        Input.apply(this, arguments);
+      }
+      inherit(SingleTouchInput, Input, {
+        handler: function TEhandler(ev) {
+          var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
+          if (type === INPUT_START) {
+            this.started = true;
           }
-        });
-        return cleanTouchActions(actions2.join(" "));
-      },
-      /**
-       * this method is called on each input cycle and provides the preventing of the browser behavior
-       * @param {Object} input
-       */
-      preventDefaults: function(input) {
-        var srcEvent = input.srcEvent;
-        var direction = input.offsetDirection;
-        if (this.manager.session.prevented) {
-          srcEvent.preventDefault();
-          return;
+          if (!this.started) {
+            return;
+          }
+          var touches = normalizeSingleTouches.call(this, ev, type);
+          if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
+            this.started = false;
+          }
+          this.callback(this.manager, type, {
+            pointers: touches[0],
+            changedPointers: touches[1],
+            pointerType: INPUT_TYPE_TOUCH,
+            srcEvent: ev
+          });
+        }
+      });
+      function normalizeSingleTouches(ev, type) {
+        var all = toArray2(ev.touches);
+        var changed = toArray2(ev.changedTouches);
+        if (type & (INPUT_END | INPUT_CANCEL)) {
+          all = uniqueArray(all.concat(changed), "identifier");
         }
-        var actions2 = this.actions;
-        var hasNone = inStr(actions2, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
-        var hasPanY = inStr(actions2, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
-        var hasPanX = inStr(actions2, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
-        if (hasNone) {
-          var isTapPointer = input.pointers.length === 1;
-          var isTapMovement = input.distance < 2;
-          var isTapTouchTime = input.deltaTime < 250;
-          if (isTapPointer && isTapMovement && isTapTouchTime) {
+        return [all, changed];
+      }
+      var TOUCH_INPUT_MAP = {
+        touchstart: INPUT_START,
+        touchmove: INPUT_MOVE,
+        touchend: INPUT_END,
+        touchcancel: INPUT_CANCEL
+      };
+      var TOUCH_TARGET_EVENTS = "touchstart touchmove touchend touchcancel";
+      function TouchInput() {
+        this.evTarget = TOUCH_TARGET_EVENTS;
+        this.targetIds = {};
+        Input.apply(this, arguments);
+      }
+      inherit(TouchInput, Input, {
+        handler: function MTEhandler(ev) {
+          var type = TOUCH_INPUT_MAP[ev.type];
+          var touches = getTouches.call(this, ev, type);
+          if (!touches) {
             return;
           }
+          this.callback(this.manager, type, {
+            pointers: touches[0],
+            changedPointers: touches[1],
+            pointerType: INPUT_TYPE_TOUCH,
+            srcEvent: ev
+          });
         }
-        if (hasPanX && hasPanY) {
-          return;
+      });
+      function getTouches(ev, type) {
+        var allTouches = toArray2(ev.touches);
+        var targetIds = this.targetIds;
+        if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
+          targetIds[allTouches[0].identifier] = true;
+          return [allTouches, allTouches];
         }
-        if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) {
-          return this.preventSrc(srcEvent);
+        var i2, targetTouches, changedTouches = toArray2(ev.changedTouches), changedTargetTouches = [], target = this.target;
+        targetTouches = allTouches.filter(function(touch) {
+          return hasParent(touch.target, target);
+        });
+        if (type === INPUT_START) {
+          i2 = 0;
+          while (i2 < targetTouches.length) {
+            targetIds[targetTouches[i2].identifier] = true;
+            i2++;
+          }
         }
-      },
-      /**
-       * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
-       * @param {Object} srcEvent
-       */
-      preventSrc: function(srcEvent) {
-        this.manager.session.prevented = true;
-        srcEvent.preventDefault();
-      }
-    };
-    function cleanTouchActions(actions2) {
-      if (inStr(actions2, TOUCH_ACTION_NONE)) {
-        return TOUCH_ACTION_NONE;
-      }
-      var hasPanX = inStr(actions2, TOUCH_ACTION_PAN_X);
-      var hasPanY = inStr(actions2, TOUCH_ACTION_PAN_Y);
-      if (hasPanX && hasPanY) {
-        return TOUCH_ACTION_NONE;
-      }
-      if (hasPanX || hasPanY) {
-        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
-      }
-      if (inStr(actions2, TOUCH_ACTION_MANIPULATION)) {
-        return TOUCH_ACTION_MANIPULATION;
-      }
-      return TOUCH_ACTION_AUTO;
-    }
-    function getTouchActionProps() {
-      if (!NATIVE_TOUCH_ACTION) {
-        return false;
-      }
-      var touchMap = {};
-      var cssSupports = window2.CSS && window2.CSS.supports;
-      ["auto", "manipulation", "pan-y", "pan-x", "pan-x pan-y", "none"].forEach(function(val) {
-        touchMap[val] = cssSupports ? window2.CSS.supports("touch-action", val) : true;
-      });
-      return touchMap;
-    }
-    var STATE_POSSIBLE = 1;
-    var STATE_BEGAN = 2;
-    var STATE_CHANGED = 4;
-    var STATE_ENDED = 8;
-    var STATE_RECOGNIZED = STATE_ENDED;
-    var STATE_CANCELLED = 16;
-    var STATE_FAILED = 32;
-    function Recognizer(options) {
-      this.options = assign({}, this.defaults, options || {});
-      this.id = uniqueId();
-      this.manager = null;
-      this.options.enable = ifUndefined(this.options.enable, true);
-      this.state = STATE_POSSIBLE;
-      this.simultaneous = {};
-      this.requireFail = [];
-    }
-    Recognizer.prototype = {
-      /**
-       * @virtual
-       * @type {Object}
-       */
-      defaults: {},
-      /**
-       * set options
-       * @param {Object} options
-       * @return {Recognizer}
-       */
-      set: function(options) {
-        assign(this.options, options);
-        this.manager && this.manager.touchAction.update();
-        return this;
-      },
-      /**
-       * recognize simultaneous with an other recognizer.
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      recognizeWith: function(otherRecognizer) {
-        if (invokeArrayArg(otherRecognizer, "recognizeWith", this)) {
-          return this;
+        i2 = 0;
+        while (i2 < changedTouches.length) {
+          if (targetIds[changedTouches[i2].identifier]) {
+            changedTargetTouches.push(changedTouches[i2]);
+          }
+          if (type & (INPUT_END | INPUT_CANCEL)) {
+            delete targetIds[changedTouches[i2].identifier];
+          }
+          i2++;
         }
-        var simultaneous = this.simultaneous;
-        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-        if (!simultaneous[otherRecognizer.id]) {
-          simultaneous[otherRecognizer.id] = otherRecognizer;
-          otherRecognizer.recognizeWith(this);
+        if (!changedTargetTouches.length) {
+          return;
         }
-        return this;
-      },
-      /**
-       * drop the simultaneous link. it doesnt remove the link on the other recognizer.
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      dropRecognizeWith: function(otherRecognizer) {
-        if (invokeArrayArg(otherRecognizer, "dropRecognizeWith", this)) {
-          return this;
+        return [
+          // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
+          uniqueArray(targetTouches.concat(changedTargetTouches), "identifier"),
+          changedTargetTouches
+        ];
+      }
+      var DEDUP_TIMEOUT = 2500;
+      var DEDUP_DISTANCE = 25;
+      function TouchMouseInput() {
+        Input.apply(this, arguments);
+        var handler = bindFn(this.handler, this);
+        this.touch = new TouchInput(this.manager, handler);
+        this.mouse = new MouseInput(this.manager, handler);
+        this.primaryTouch = null;
+        this.lastTouches = [];
+      }
+      inherit(TouchMouseInput, Input, {
+        /**
+         * handle mouse and touch events
+         * @param {Hammer} manager
+         * @param {String} inputEvent
+         * @param {Object} inputData
+         */
+        handler: function TMEhandler(manager, inputEvent, inputData) {
+          var isTouch = inputData.pointerType == INPUT_TYPE_TOUCH, isMouse = inputData.pointerType == INPUT_TYPE_MOUSE;
+          if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
+            return;
+          }
+          if (isTouch) {
+            recordTouches.call(this, inputEvent, inputData);
+          } else if (isMouse && isSyntheticEvent.call(this, inputData)) {
+            return;
+          }
+          this.callback(manager, inputEvent, inputData);
+        },
+        /**
+         * remove the event listeners
+         */
+        destroy: function destroy() {
+          this.touch.destroy();
+          this.mouse.destroy();
         }
-        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-        delete this.simultaneous[otherRecognizer.id];
-        return this;
-      },
-      /**
-       * recognizer can only run when an other is failing
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      requireFailure: function(otherRecognizer) {
-        if (invokeArrayArg(otherRecognizer, "requireFailure", this)) {
-          return this;
+      });
+      function recordTouches(eventType, eventData) {
+        if (eventType & INPUT_START) {
+          this.primaryTouch = eventData.changedPointers[0].identifier;
+          setLastTouch.call(this, eventData);
+        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
+          setLastTouch.call(this, eventData);
         }
-        var requireFail = this.requireFail;
-        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-        if (inArray(requireFail, otherRecognizer) === -1) {
-          requireFail.push(otherRecognizer);
-          otherRecognizer.requireFailure(this);
+      }
+      function setLastTouch(eventData) {
+        var touch = eventData.changedPointers[0];
+        if (touch.identifier === this.primaryTouch) {
+          var lastTouch = { x: touch.clientX, y: touch.clientY };
+          this.lastTouches.push(lastTouch);
+          var lts = this.lastTouches;
+          var removeLastTouch = function() {
+            var i2 = lts.indexOf(lastTouch);
+            if (i2 > -1) {
+              lts.splice(i2, 1);
+            }
+          };
+          setTimeout(removeLastTouch, DEDUP_TIMEOUT);
         }
-        return this;
-      },
-      /**
-       * drop the requireFailure link. it does not remove the link on the other recognizer.
-       * @param {Recognizer} otherRecognizer
-       * @returns {Recognizer} this
-       */
-      dropRequireFailure: function(otherRecognizer) {
-        if (invokeArrayArg(otherRecognizer, "dropRequireFailure", this)) {
-          return this;
+      }
+      function isSyntheticEvent(eventData) {
+        var x2 = eventData.srcEvent.clientX, y2 = eventData.srcEvent.clientY;
+        for (var i2 = 0; i2 < this.lastTouches.length; i2++) {
+          var t = this.lastTouches[i2];
+          var dx = Math.abs(x2 - t.x), dy = Math.abs(y2 - t.y);
+          if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
+            return true;
+          }
         }
-        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
-        var index2 = inArray(this.requireFail, otherRecognizer);
-        if (index2 > -1) {
-          this.requireFail.splice(index2, 1);
+        return false;
+      }
+      var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, "touchAction");
+      var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined$1;
+      var TOUCH_ACTION_COMPUTE = "compute";
+      var TOUCH_ACTION_AUTO = "auto";
+      var TOUCH_ACTION_MANIPULATION = "manipulation";
+      var TOUCH_ACTION_NONE = "none";
+      var TOUCH_ACTION_PAN_X = "pan-x";
+      var TOUCH_ACTION_PAN_Y = "pan-y";
+      var TOUCH_ACTION_MAP = getTouchActionProps();
+      function TouchAction(manager, value) {
+        this.manager = manager;
+        this.set(value);
+      }
+      TouchAction.prototype = {
+        /**
+         * set the touchAction value on the element or enable the polyfill
+         * @param {String} value
+         */
+        set: function(value) {
+          if (value == TOUCH_ACTION_COMPUTE) {
+            value = this.compute();
+          }
+          if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
+            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
+          }
+          this.actions = value.toLowerCase().trim();
+        },
+        /**
+         * just re-set the touchAction value
+         */
+        update: function() {
+          this.set(this.manager.options.touchAction);
+        },
+        /**
+         * compute the value for the touchAction property based on the recognizer's settings
+         * @returns {String} value
+         */
+        compute: function() {
+          var actions2 = [];
+          each2(this.manager.recognizers, function(recognizer) {
+            if (boolOrFn(recognizer.options.enable, [recognizer])) {
+              actions2 = actions2.concat(recognizer.getTouchAction());
+            }
+          });
+          return cleanTouchActions(actions2.join(" "));
+        },
+        /**
+         * this method is called on each input cycle and provides the preventing of the browser behavior
+         * @param {Object} input
+         */
+        preventDefaults: function(input) {
+          var srcEvent = input.srcEvent;
+          var direction = input.offsetDirection;
+          if (this.manager.session.prevented) {
+            srcEvent.preventDefault();
+            return;
+          }
+          var actions2 = this.actions;
+          var hasNone = inStr(actions2, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
+          var hasPanY = inStr(actions2, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
+          var hasPanX = inStr(actions2, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
+          if (hasNone) {
+            var isTapPointer = input.pointers.length === 1;
+            var isTapMovement = input.distance < 2;
+            var isTapTouchTime = input.deltaTime < 250;
+            if (isTapPointer && isTapMovement && isTapTouchTime) {
+              return;
+            }
+          }
+          if (hasPanX && hasPanY) {
+            return;
+          }
+          if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) {
+            return this.preventSrc(srcEvent);
+          }
+        },
+        /**
+         * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
+         * @param {Object} srcEvent
+         */
+        preventSrc: function(srcEvent) {
+          this.manager.session.prevented = true;
+          srcEvent.preventDefault();
         }
-        return this;
-      },
-      /**
-       * has require failures boolean
-       * @returns {boolean}
-       */
-      hasRequireFailures: function() {
-        return this.requireFail.length > 0;
-      },
-      /**
-       * if the recognizer can recognize simultaneous with an other recognizer
-       * @param {Recognizer} otherRecognizer
-       * @returns {Boolean}
-       */
-      canRecognizeWith: function(otherRecognizer) {
-        return !!this.simultaneous[otherRecognizer.id];
-      },
-      /**
-       * You should use `tryEmit` instead of `emit` directly to check
-       * that all the needed recognizers has failed before emitting.
-       * @param {Object} input
-       */
-      emit: function(input) {
-        var self2 = this;
-        var state = this.state;
-        function emit(event) {
-          self2.manager.emit(event, input);
+      };
+      function cleanTouchActions(actions2) {
+        if (inStr(actions2, TOUCH_ACTION_NONE)) {
+          return TOUCH_ACTION_NONE;
         }
-        if (state < STATE_ENDED) {
-          emit(self2.options.event + stateStr(state));
+        var hasPanX = inStr(actions2, TOUCH_ACTION_PAN_X);
+        var hasPanY = inStr(actions2, TOUCH_ACTION_PAN_Y);
+        if (hasPanX && hasPanY) {
+          return TOUCH_ACTION_NONE;
         }
-        emit(self2.options.event);
-        if (input.additionalEvent) {
-          emit(input.additionalEvent);
+        if (hasPanX || hasPanY) {
+          return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
         }
-        if (state >= STATE_ENDED) {
-          emit(self2.options.event + stateStr(state));
+        if (inStr(actions2, TOUCH_ACTION_MANIPULATION)) {
+          return TOUCH_ACTION_MANIPULATION;
         }
-      },
-      /**
-       * Check that all the require failure recognizers has failed,
-       * if true, it emits a gesture event,
-       * otherwise, setup the state to FAILED.
-       * @param {Object} input
-       */
-      tryEmit: function(input) {
-        if (this.canEmit()) {
-          return this.emit(input);
+        return TOUCH_ACTION_AUTO;
+      }
+      function getTouchActionProps() {
+        if (!NATIVE_TOUCH_ACTION) {
+          return false;
         }
-        this.state = STATE_FAILED;
-      },
-      /**
-       * can we emit?
-       * @returns {boolean}
-       */
-      canEmit: function() {
-        var i2 = 0;
-        while (i2 < this.requireFail.length) {
-          if (!(this.requireFail[i2].state & (STATE_FAILED | STATE_POSSIBLE))) {
-            return false;
+        var touchMap = {};
+        var cssSupports = window2.CSS && window2.CSS.supports;
+        ["auto", "manipulation", "pan-y", "pan-x", "pan-x pan-y", "none"].forEach(function(val) {
+          touchMap[val] = cssSupports ? window2.CSS.supports("touch-action", val) : true;
+        });
+        return touchMap;
+      }
+      var STATE_POSSIBLE = 1;
+      var STATE_BEGAN = 2;
+      var STATE_CHANGED = 4;
+      var STATE_ENDED = 8;
+      var STATE_RECOGNIZED = STATE_ENDED;
+      var STATE_CANCELLED = 16;
+      var STATE_FAILED = 32;
+      function Recognizer(options) {
+        this.options = assign({}, this.defaults, options || {});
+        this.id = uniqueId();
+        this.manager = null;
+        this.options.enable = ifUndefined(this.options.enable, true);
+        this.state = STATE_POSSIBLE;
+        this.simultaneous = {};
+        this.requireFail = [];
+      }
+      Recognizer.prototype = {
+        /**
+         * @virtual
+         * @type {Object}
+         */
+        defaults: {},
+        /**
+         * set options
+         * @param {Object} options
+         * @return {Recognizer}
+         */
+        set: function(options) {
+          assign(this.options, options);
+          this.manager && this.manager.touchAction.update();
+          return this;
+        },
+        /**
+         * recognize simultaneous with an other recognizer.
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        recognizeWith: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, "recognizeWith", this)) {
+            return this;
+          }
+          var simultaneous = this.simultaneous;
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          if (!simultaneous[otherRecognizer.id]) {
+            simultaneous[otherRecognizer.id] = otherRecognizer;
+            otherRecognizer.recognizeWith(this);
+          }
+          return this;
+        },
+        /**
+         * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        dropRecognizeWith: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, "dropRecognizeWith", this)) {
+            return this;
+          }
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          delete this.simultaneous[otherRecognizer.id];
+          return this;
+        },
+        /**
+         * recognizer can only run when an other is failing
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        requireFailure: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, "requireFailure", this)) {
+            return this;
+          }
+          var requireFail = this.requireFail;
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          if (inArray(requireFail, otherRecognizer) === -1) {
+            requireFail.push(otherRecognizer);
+            otherRecognizer.requireFailure(this);
+          }
+          return this;
+        },
+        /**
+         * drop the requireFailure link. it does not remove the link on the other recognizer.
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        dropRequireFailure: function(otherRecognizer) {
+          if (invokeArrayArg(otherRecognizer, "dropRequireFailure", this)) {
+            return this;
+          }
+          otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
+          var index2 = inArray(this.requireFail, otherRecognizer);
+          if (index2 > -1) {
+            this.requireFail.splice(index2, 1);
+          }
+          return this;
+        },
+        /**
+         * has require failures boolean
+         * @returns {boolean}
+         */
+        hasRequireFailures: function() {
+          return this.requireFail.length > 0;
+        },
+        /**
+         * if the recognizer can recognize simultaneous with an other recognizer
+         * @param {Recognizer} otherRecognizer
+         * @returns {Boolean}
+         */
+        canRecognizeWith: function(otherRecognizer) {
+          return !!this.simultaneous[otherRecognizer.id];
+        },
+        /**
+         * You should use `tryEmit` instead of `emit` directly to check
+         * that all the needed recognizers has failed before emitting.
+         * @param {Object} input
+         */
+        emit: function(input) {
+          var self2 = this;
+          var state = this.state;
+          function emit(event) {
+            self2.manager.emit(event, input);
+          }
+          if (state < STATE_ENDED) {
+            emit(self2.options.event + stateStr(state));
+          }
+          emit(self2.options.event);
+          if (input.additionalEvent) {
+            emit(input.additionalEvent);
+          }
+          if (state >= STATE_ENDED) {
+            emit(self2.options.event + stateStr(state));
+          }
+        },
+        /**
+         * Check that all the require failure recognizers has failed,
+         * if true, it emits a gesture event,
+         * otherwise, setup the state to FAILED.
+         * @param {Object} input
+         */
+        tryEmit: function(input) {
+          if (this.canEmit()) {
+            return this.emit(input);
           }
-          i2++;
-        }
-        return true;
-      },
-      /**
-       * update the recognizer
-       * @param {Object} inputData
-       */
-      recognize: function(inputData) {
-        var inputDataClone = assign({}, inputData);
-        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
-          this.reset();
           this.state = STATE_FAILED;
-          return;
+        },
+        /**
+         * can we emit?
+         * @returns {boolean}
+         */
+        canEmit: function() {
+          var i2 = 0;
+          while (i2 < this.requireFail.length) {
+            if (!(this.requireFail[i2].state & (STATE_FAILED | STATE_POSSIBLE))) {
+              return false;
+            }
+            i2++;
+          }
+          return true;
+        },
+        /**
+         * update the recognizer
+         * @param {Object} inputData
+         */
+        recognize: function(inputData) {
+          var inputDataClone = assign({}, inputData);
+          if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
+            this.reset();
+            this.state = STATE_FAILED;
+            return;
+          }
+          if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
+            this.state = STATE_POSSIBLE;
+          }
+          this.state = this.process(inputDataClone);
+          if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
+            this.tryEmit(inputDataClone);
+          }
+        },
+        /**
+         * return the state of the recognizer
+         * the actual recognizing happens in this method
+         * @virtual
+         * @param {Object} inputData
+         * @returns {Const} STATE
+         */
+        process: function(inputData) {
+        },
+        // jshint ignore:line
+        /**
+         * return the preferred touch-action
+         * @virtual
+         * @returns {Array}
+         */
+        getTouchAction: function() {
+        },
+        /**
+         * called when the gesture isn't allowed to recognize
+         * like when another is being recognized or it is disabled
+         * @virtual
+         */
+        reset: function() {
+        }
+      };
+      function stateStr(state) {
+        if (state & STATE_CANCELLED) {
+          return "cancel";
+        } else if (state & STATE_ENDED) {
+          return "end";
+        } else if (state & STATE_CHANGED) {
+          return "move";
+        } else if (state & STATE_BEGAN) {
+          return "start";
         }
-        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
-          this.state = STATE_POSSIBLE;
+        return "";
+      }
+      function directionStr(direction) {
+        if (direction == DIRECTION_DOWN) {
+          return "down";
+        } else if (direction == DIRECTION_UP) {
+          return "up";
+        } else if (direction == DIRECTION_LEFT) {
+          return "left";
+        } else if (direction == DIRECTION_RIGHT) {
+          return "right";
         }
-        this.state = this.process(inputDataClone);
-        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
-          this.tryEmit(inputDataClone);
+        return "";
+      }
+      function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
+        var manager = recognizer.manager;
+        if (manager) {
+          return manager.get(otherRecognizer);
         }
-      },
-      /**
-       * return the state of the recognizer
-       * the actual recognizing happens in this method
-       * @virtual
-       * @param {Object} inputData
-       * @returns {Const} STATE
-       */
-      process: function(inputData) {
-      },
-      // jshint ignore:line
-      /**
-       * return the preferred touch-action
-       * @virtual
-       * @returns {Array}
-       */
-      getTouchAction: function() {
-      },
-      /**
-       * called when the gesture isn't allowed to recognize
-       * like when another is being recognized or it is disabled
-       * @virtual
-       */
-      reset: function() {
+        return otherRecognizer;
       }
-    };
-    function stateStr(state) {
-      if (state & STATE_CANCELLED) {
-        return "cancel";
-      } else if (state & STATE_ENDED) {
-        return "end";
-      } else if (state & STATE_CHANGED) {
-        return "move";
-      } else if (state & STATE_BEGAN) {
-        return "start";
-      }
-      return "";
-    }
-    function directionStr(direction) {
-      if (direction == DIRECTION_DOWN) {
-        return "down";
-      } else if (direction == DIRECTION_UP) {
-        return "up";
-      } else if (direction == DIRECTION_LEFT) {
-        return "left";
-      } else if (direction == DIRECTION_RIGHT) {
-        return "right";
-      }
-      return "";
-    }
-    function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
-      var manager = recognizer.manager;
-      if (manager) {
-        return manager.get(otherRecognizer);
-      }
-      return otherRecognizer;
-    }
-    function AttrRecognizer() {
-      Recognizer.apply(this, arguments);
-    }
-    inherit(AttrRecognizer, Recognizer, {
-      /**
-       * @namespace
-       * @memberof AttrRecognizer
-       */
-      defaults: {
+      function AttrRecognizer() {
+        Recognizer.apply(this, arguments);
+      }
+      inherit(AttrRecognizer, Recognizer, {
         /**
-         * @type {Number}
-         * @default 1
+         * @namespace
+         * @memberof AttrRecognizer
          */
-        pointers: 1
-      },
-      /**
-       * Used to check if it the recognizer receives valid input, like input.distance > 10.
-       * @memberof AttrRecognizer
-       * @param {Object} input
-       * @returns {Boolean} recognized
-       */
-      attrTest: function(input) {
-        var optionPointers = this.options.pointers;
-        return optionPointers === 0 || input.pointers.length === optionPointers;
-      },
-      /**
-       * Process the input and return the state for the recognizer
-       * @memberof AttrRecognizer
-       * @param {Object} input
-       * @returns {*} State
-       */
-      process: function(input) {
-        var state = this.state;
-        var eventType = input.eventType;
-        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
-        var isValid = this.attrTest(input);
-        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
-          return state | STATE_CANCELLED;
-        } else if (isRecognized || isValid) {
-          if (eventType & INPUT_END) {
-            return state | STATE_ENDED;
-          } else if (!(state & STATE_BEGAN)) {
-            return STATE_BEGAN;
+        defaults: {
+          /**
+           * @type {Number}
+           * @default 1
+           */
+          pointers: 1
+        },
+        /**
+         * Used to check if it the recognizer receives valid input, like input.distance > 10.
+         * @memberof AttrRecognizer
+         * @param {Object} input
+         * @returns {Boolean} recognized
+         */
+        attrTest: function(input) {
+          var optionPointers = this.options.pointers;
+          return optionPointers === 0 || input.pointers.length === optionPointers;
+        },
+        /**
+         * Process the input and return the state for the recognizer
+         * @memberof AttrRecognizer
+         * @param {Object} input
+         * @returns {*} State
+         */
+        process: function(input) {
+          var state = this.state;
+          var eventType = input.eventType;
+          var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
+          var isValid = this.attrTest(input);
+          if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
+            return state | STATE_CANCELLED;
+          } else if (isRecognized || isValid) {
+            if (eventType & INPUT_END) {
+              return state | STATE_ENDED;
+            } else if (!(state & STATE_BEGAN)) {
+              return STATE_BEGAN;
+            }
+            return state | STATE_CHANGED;
           }
-          return state | STATE_CHANGED;
+          return STATE_FAILED;
         }
-        return STATE_FAILED;
+      });
+      function PanRecognizer() {
+        AttrRecognizer.apply(this, arguments);
+        this.pX = null;
+        this.pY = null;
       }
-    });
-    function PanRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-      this.pX = null;
-      this.pY = null;
-    }
-    inherit(PanRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof PanRecognizer
-       */
-      defaults: {
-        event: "pan",
-        threshold: 10,
-        pointers: 1,
-        direction: DIRECTION_ALL
-      },
-      getTouchAction: function() {
-        var direction = this.options.direction;
-        var actions2 = [];
-        if (direction & DIRECTION_HORIZONTAL) {
-          actions2.push(TOUCH_ACTION_PAN_Y);
+      inherit(PanRecognizer, AttrRecognizer, {
+        /**
+         * @namespace
+         * @memberof PanRecognizer
+         */
+        defaults: {
+          event: "pan",
+          threshold: 10,
+          pointers: 1,
+          direction: DIRECTION_ALL
+        },
+        getTouchAction: function() {
+          var direction = this.options.direction;
+          var actions2 = [];
+          if (direction & DIRECTION_HORIZONTAL) {
+            actions2.push(TOUCH_ACTION_PAN_Y);
+          }
+          if (direction & DIRECTION_VERTICAL) {
+            actions2.push(TOUCH_ACTION_PAN_X);
+          }
+          return actions2;
+        },
+        directionTest: function(input) {
+          var options = this.options;
+          var hasMoved = true;
+          var distance = input.distance;
+          var direction = input.direction;
+          var x2 = input.deltaX;
+          var y2 = input.deltaY;
+          if (!(direction & options.direction)) {
+            if (options.direction & DIRECTION_HORIZONTAL) {
+              direction = x2 === 0 ? DIRECTION_NONE : x2 < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
+              hasMoved = x2 != this.pX;
+              distance = Math.abs(input.deltaX);
+            } else {
+              direction = y2 === 0 ? DIRECTION_NONE : y2 < 0 ? DIRECTION_UP : DIRECTION_DOWN;
+              hasMoved = y2 != this.pY;
+              distance = Math.abs(input.deltaY);
+            }
+          }
+          input.direction = direction;
+          return hasMoved && distance > options.threshold && direction & options.direction;
+        },
+        attrTest: function(input) {
+          return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
+        },
+        emit: function(input) {
+          this.pX = input.deltaX;
+          this.pY = input.deltaY;
+          var direction = directionStr(input.direction);
+          if (direction) {
+            input.additionalEvent = this.options.event + direction;
+          }
+          this._super.emit.call(this, input);
         }
-        if (direction & DIRECTION_VERTICAL) {
-          actions2.push(TOUCH_ACTION_PAN_X);
+      });
+      function PinchRecognizer() {
+        AttrRecognizer.apply(this, arguments);
+      }
+      inherit(PinchRecognizer, AttrRecognizer, {
+        /**
+         * @namespace
+         * @memberof PinchRecognizer
+         */
+        defaults: {
+          event: "pinch",
+          threshold: 0,
+          pointers: 2
+        },
+        getTouchAction: function() {
+          return [TOUCH_ACTION_NONE];
+        },
+        attrTest: function(input) {
+          return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
+        },
+        emit: function(input) {
+          if (input.scale !== 1) {
+            var inOut = input.scale < 1 ? "in" : "out";
+            input.additionalEvent = this.options.event + inOut;
+          }
+          this._super.emit.call(this, input);
         }
-        return actions2;
-      },
-      directionTest: function(input) {
-        var options = this.options;
-        var hasMoved = true;
-        var distance = input.distance;
-        var direction = input.direction;
-        var x2 = input.deltaX;
-        var y2 = input.deltaY;
-        if (!(direction & options.direction)) {
-          if (options.direction & DIRECTION_HORIZONTAL) {
-            direction = x2 === 0 ? DIRECTION_NONE : x2 < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
-            hasMoved = x2 != this.pX;
-            distance = Math.abs(input.deltaX);
+      });
+      function PressRecognizer() {
+        Recognizer.apply(this, arguments);
+        this._timer = null;
+        this._input = null;
+      }
+      inherit(PressRecognizer, Recognizer, {
+        /**
+         * @namespace
+         * @memberof PressRecognizer
+         */
+        defaults: {
+          event: "press",
+          pointers: 1,
+          time: 251,
+          // minimal time of the pointer to be pressed
+          threshold: 9
+          // a minimal movement is ok, but keep it low
+        },
+        getTouchAction: function() {
+          return [TOUCH_ACTION_AUTO];
+        },
+        process: function(input) {
+          var options = this.options;
+          var validPointers = input.pointers.length === options.pointers;
+          var validMovement = input.distance < options.threshold;
+          var validTime = input.deltaTime > options.time;
+          this._input = input;
+          if (!validMovement || !validPointers || input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime) {
+            this.reset();
+          } else if (input.eventType & INPUT_START) {
+            this.reset();
+            this._timer = setTimeoutContext(function() {
+              this.state = STATE_RECOGNIZED;
+              this.tryEmit();
+            }, options.time, this);
+          } else if (input.eventType & INPUT_END) {
+            return STATE_RECOGNIZED;
+          }
+          return STATE_FAILED;
+        },
+        reset: function() {
+          clearTimeout(this._timer);
+        },
+        emit: function(input) {
+          if (this.state !== STATE_RECOGNIZED) {
+            return;
+          }
+          if (input && input.eventType & INPUT_END) {
+            this.manager.emit(this.options.event + "up", input);
           } else {
-            direction = y2 === 0 ? DIRECTION_NONE : y2 < 0 ? DIRECTION_UP : DIRECTION_DOWN;
-            hasMoved = y2 != this.pY;
-            distance = Math.abs(input.deltaY);
+            this._input.timeStamp = now();
+            this.manager.emit(this.options.event, this._input);
           }
         }
-        input.direction = direction;
-        return hasMoved && distance > options.threshold && direction & options.direction;
-      },
-      attrTest: function(input) {
-        return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
-      },
-      emit: function(input) {
-        this.pX = input.deltaX;
-        this.pY = input.deltaY;
-        var direction = directionStr(input.direction);
-        if (direction) {
-          input.additionalEvent = this.options.event + direction;
-        }
-        this._super.emit.call(this, input);
+      });
+      function RotateRecognizer() {
+        AttrRecognizer.apply(this, arguments);
       }
-    });
-    function PinchRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-    }
-    inherit(PinchRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof PinchRecognizer
-       */
-      defaults: {
-        event: "pinch",
-        threshold: 0,
-        pointers: 2
-      },
-      getTouchAction: function() {
-        return [TOUCH_ACTION_NONE];
-      },
-      attrTest: function(input) {
-        return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
-      },
-      emit: function(input) {
-        if (input.scale !== 1) {
-          var inOut = input.scale < 1 ? "in" : "out";
-          input.additionalEvent = this.options.event + inOut;
+      inherit(RotateRecognizer, AttrRecognizer, {
+        /**
+         * @namespace
+         * @memberof RotateRecognizer
+         */
+        defaults: {
+          event: "rotate",
+          threshold: 0,
+          pointers: 2
+        },
+        getTouchAction: function() {
+          return [TOUCH_ACTION_NONE];
+        },
+        attrTest: function(input) {
+          return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
         }
-        this._super.emit.call(this, input);
+      });
+      function SwipeRecognizer() {
+        AttrRecognizer.apply(this, arguments);
       }
-    });
-    function PressRecognizer() {
-      Recognizer.apply(this, arguments);
-      this._timer = null;
-      this._input = null;
-    }
-    inherit(PressRecognizer, Recognizer, {
-      /**
-       * @namespace
-       * @memberof PressRecognizer
-       */
-      defaults: {
-        event: "press",
-        pointers: 1,
-        time: 251,
-        // minimal time of the pointer to be pressed
-        threshold: 9
-        // a minimal movement is ok, but keep it low
-      },
-      getTouchAction: function() {
-        return [TOUCH_ACTION_AUTO];
-      },
-      process: function(input) {
-        var options = this.options;
-        var validPointers = input.pointers.length === options.pointers;
-        var validMovement = input.distance < options.threshold;
-        var validTime = input.deltaTime > options.time;
-        this._input = input;
-        if (!validMovement || !validPointers || input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime) {
-          this.reset();
-        } else if (input.eventType & INPUT_START) {
+      inherit(SwipeRecognizer, AttrRecognizer, {
+        /**
+         * @namespace
+         * @memberof SwipeRecognizer
+         */
+        defaults: {
+          event: "swipe",
+          threshold: 10,
+          velocity: 0.3,
+          direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
+          pointers: 1
+        },
+        getTouchAction: function() {
+          return PanRecognizer.prototype.getTouchAction.call(this);
+        },
+        attrTest: function(input) {
+          var direction = this.options.direction;
+          var velocity;
+          if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
+            velocity = input.overallVelocity;
+          } else if (direction & DIRECTION_HORIZONTAL) {
+            velocity = input.overallVelocityX;
+          } else if (direction & DIRECTION_VERTICAL) {
+            velocity = input.overallVelocityY;
+          }
+          return this._super.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
+        },
+        emit: function(input) {
+          var direction = directionStr(input.offsetDirection);
+          if (direction) {
+            this.manager.emit(this.options.event + direction, input);
+          }
+          this.manager.emit(this.options.event, input);
+        }
+      });
+      function TapRecognizer() {
+        Recognizer.apply(this, arguments);
+        this.pTime = false;
+        this.pCenter = false;
+        this._timer = null;
+        this._input = null;
+        this.count = 0;
+      }
+      inherit(TapRecognizer, Recognizer, {
+        /**
+         * @namespace
+         * @memberof PinchRecognizer
+         */
+        defaults: {
+          event: "tap",
+          pointers: 1,
+          taps: 1,
+          interval: 300,
+          // max time between the multi-tap taps
+          time: 250,
+          // max time of the pointer to be down (like finger on the screen)
+          threshold: 9,
+          // a minimal movement is ok, but keep it low
+          posThreshold: 10
+          // a multi-tap can be a bit off the initial position
+        },
+        getTouchAction: function() {
+          return [TOUCH_ACTION_MANIPULATION];
+        },
+        process: function(input) {
+          var options = this.options;
+          var validPointers = input.pointers.length === options.pointers;
+          var validMovement = input.distance < options.threshold;
+          var validTouchTime = input.deltaTime < options.time;
           this.reset();
+          if (input.eventType & INPUT_START && this.count === 0) {
+            return this.failTimeout();
+          }
+          if (validMovement && validTouchTime && validPointers) {
+            if (input.eventType != INPUT_END) {
+              return this.failTimeout();
+            }
+            var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
+            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
+            this.pTime = input.timeStamp;
+            this.pCenter = input.center;
+            if (!validMultiTap || !validInterval) {
+              this.count = 1;
+            } else {
+              this.count += 1;
+            }
+            this._input = input;
+            var tapCount = this.count % options.taps;
+            if (tapCount === 0) {
+              if (!this.hasRequireFailures()) {
+                return STATE_RECOGNIZED;
+              } else {
+                this._timer = setTimeoutContext(function() {
+                  this.state = STATE_RECOGNIZED;
+                  this.tryEmit();
+                }, options.interval, this);
+                return STATE_BEGAN;
+              }
+            }
+          }
+          return STATE_FAILED;
+        },
+        failTimeout: function() {
           this._timer = setTimeoutContext(function() {
-            this.state = STATE_RECOGNIZED;
-            this.tryEmit();
-          }, options.time, this);
-        } else if (input.eventType & INPUT_END) {
-          return STATE_RECOGNIZED;
-        }
-        return STATE_FAILED;
-      },
-      reset: function() {
-        clearTimeout(this._timer);
-      },
-      emit: function(input) {
-        if (this.state !== STATE_RECOGNIZED) {
-          return;
-        }
-        if (input && input.eventType & INPUT_END) {
-          this.manager.emit(this.options.event + "up", input);
-        } else {
-          this._input.timeStamp = now();
-          this.manager.emit(this.options.event, this._input);
+            this.state = STATE_FAILED;
+          }, this.options.interval, this);
+          return STATE_FAILED;
+        },
+        reset: function() {
+          clearTimeout(this._timer);
+        },
+        emit: function() {
+          if (this.state == STATE_RECOGNIZED) {
+            this._input.tapCount = this.count;
+            this.manager.emit(this.options.event, this._input);
+          }
         }
+      });
+      function Hammer2(element, options) {
+        options = options || {};
+        options.recognizers = ifUndefined(options.recognizers, Hammer2.defaults.preset);
+        return new Manager(element, options);
       }
-    });
-    function RotateRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-    }
-    inherit(RotateRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof RotateRecognizer
-       */
-      defaults: {
-        event: "rotate",
-        threshold: 0,
-        pointers: 2
-      },
-      getTouchAction: function() {
-        return [TOUCH_ACTION_NONE];
-      },
-      attrTest: function(input) {
-        return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
-      }
-    });
-    function SwipeRecognizer() {
-      AttrRecognizer.apply(this, arguments);
-    }
-    inherit(SwipeRecognizer, AttrRecognizer, {
-      /**
-       * @namespace
-       * @memberof SwipeRecognizer
-       */
-      defaults: {
-        event: "swipe",
-        threshold: 10,
-        velocity: 0.3,
-        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
-        pointers: 1
-      },
-      getTouchAction: function() {
-        return PanRecognizer.prototype.getTouchAction.call(this);
-      },
-      attrTest: function(input) {
-        var direction = this.options.direction;
-        var velocity;
-        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
-          velocity = input.overallVelocity;
-        } else if (direction & DIRECTION_HORIZONTAL) {
-          velocity = input.overallVelocityX;
-        } else if (direction & DIRECTION_VERTICAL) {
-          velocity = input.overallVelocityY;
-        }
-        return this._super.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers == this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
-      },
-      emit: function(input) {
-        var direction = directionStr(input.offsetDirection);
-        if (direction) {
-          this.manager.emit(this.options.event + direction, input);
+      Hammer2.VERSION = "2.0.7";
+      Hammer2.defaults = {
+        /**
+         * set if DOM events are being triggered.
+         * But this is slower and unused by simple implementations, so disabled by default.
+         * @type {Boolean}
+         * @default false
+         */
+        domEvents: false,
+        /**
+         * The value for the touchAction property/fallback.
+         * When set to `compute` it will magically set the correct value based on the added recognizers.
+         * @type {String}
+         * @default compute
+         */
+        touchAction: TOUCH_ACTION_COMPUTE,
+        /**
+         * @type {Boolean}
+         * @default true
+         */
+        enable: true,
+        /**
+         * EXPERIMENTAL FEATURE -- can be removed/changed
+         * Change the parent input target element.
+         * If Null, then it is being set the to main element.
+         * @type {Null|EventTarget}
+         * @default null
+         */
+        inputTarget: null,
+        /**
+         * force an input class
+         * @type {Null|Function}
+         * @default null
+         */
+        inputClass: null,
+        /**
+         * Default recognizer setup when calling `Hammer()`
+         * When creating a new Manager these will be skipped.
+         * @type {Array}
+         */
+        preset: [
+          // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
+          [RotateRecognizer, { enable: false }],
+          [PinchRecognizer, { enable: false }, ["rotate"]],
+          [SwipeRecognizer, { direction: DIRECTION_HORIZONTAL }],
+          [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ["swipe"]],
+          [TapRecognizer],
+          [TapRecognizer, { event: "doubletap", taps: 2 }, ["tap"]],
+          [PressRecognizer]
+        ],
+        /**
+         * Some CSS properties can be used to improve the working of Hammer.
+         * Add them to this method and they will be set when creating a new Manager.
+         * @namespace
+         */
+        cssProps: {
+          /**
+           * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
+           * @type {String}
+           * @default 'none'
+           */
+          userSelect: "none",
+          /**
+           * Disable the Windows Phone grippers when pressing an element.
+           * @type {String}
+           * @default 'none'
+           */
+          touchSelect: "none",
+          /**
+           * Disables the default callout shown when you touch and hold a touch target.
+           * On iOS, when you touch and hold a touch target such as a link, Safari displays
+           * a callout containing information about the link. This property allows you to disable that callout.
+           * @type {String}
+           * @default 'none'
+           */
+          touchCallout: "none",
+          /**
+           * Specifies whether zooming is enabled. Used by IE10>
+           * @type {String}
+           * @default 'none'
+           */
+          contentZooming: "none",
+          /**
+           * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
+           * @type {String}
+           * @default 'none'
+           */
+          userDrag: "none",
+          /**
+           * Overrides the highlight color shown when the user taps a link or a JavaScript
+           * clickable element in iOS. This property obeys the alpha value, if specified.
+           * @type {String}
+           * @default 'rgba(0,0,0,0)'
+           */
+          tapHighlightColor: "rgba(0,0,0,0)"
         }
-        this.manager.emit(this.options.event, input);
+      };
+      var STOP = 1;
+      var FORCED_STOP = 2;
+      function Manager(element, options) {
+        this.options = assign({}, Hammer2.defaults, options || {});
+        this.options.inputTarget = this.options.inputTarget || element;
+        this.handlers = {};
+        this.session = {};
+        this.recognizers = [];
+        this.oldCssProps = {};
+        this.element = element;
+        this.input = createInputInstance(this);
+        this.touchAction = new TouchAction(this, this.options.touchAction);
+        toggleCssProps(this, true);
+        each2(this.options.recognizers, function(item) {
+          var recognizer = this.add(new item[0](item[1]));
+          item[2] && recognizer.recognizeWith(item[2]);
+          item[3] && recognizer.requireFailure(item[3]);
+        }, this);
       }
-    });
-    function TapRecognizer() {
-      Recognizer.apply(this, arguments);
-      this.pTime = false;
-      this.pCenter = false;
-      this._timer = null;
-      this._input = null;
-      this.count = 0;
-    }
-    inherit(TapRecognizer, Recognizer, {
-      /**
-       * @namespace
-       * @memberof PinchRecognizer
-       */
-      defaults: {
-        event: "tap",
-        pointers: 1,
-        taps: 1,
-        interval: 300,
-        // max time between the multi-tap taps
-        time: 250,
-        // max time of the pointer to be down (like finger on the screen)
-        threshold: 9,
-        // a minimal movement is ok, but keep it low
-        posThreshold: 10
-        // a multi-tap can be a bit off the initial position
-      },
-      getTouchAction: function() {
-        return [TOUCH_ACTION_MANIPULATION];
-      },
-      process: function(input) {
-        var options = this.options;
-        var validPointers = input.pointers.length === options.pointers;
-        var validMovement = input.distance < options.threshold;
-        var validTouchTime = input.deltaTime < options.time;
-        this.reset();
-        if (input.eventType & INPUT_START && this.count === 0) {
-          return this.failTimeout();
-        }
-        if (validMovement && validTouchTime && validPointers) {
-          if (input.eventType != INPUT_END) {
-            return this.failTimeout();
+      Manager.prototype = {
+        /**
+         * set options
+         * @param {Object} options
+         * @returns {Manager}
+         */
+        set: function(options) {
+          assign(this.options, options);
+          if (options.touchAction) {
+            this.touchAction.update();
           }
-          var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
-          var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
-          this.pTime = input.timeStamp;
-          this.pCenter = input.center;
-          if (!validMultiTap || !validInterval) {
-            this.count = 1;
-          } else {
-            this.count += 1;
+          if (options.inputTarget) {
+            this.input.destroy();
+            this.input.target = options.inputTarget;
+            this.input.init();
           }
-          this._input = input;
-          var tapCount = this.count % options.taps;
-          if (tapCount === 0) {
-            if (!this.hasRequireFailures()) {
-              return STATE_RECOGNIZED;
+          return this;
+        },
+        /**
+         * stop recognizing for this session.
+         * This session will be discarded, when a new [input]start event is fired.
+         * When forced, the recognizer cycle is stopped immediately.
+         * @param {Boolean} [force]
+         */
+        stop: function(force) {
+          this.session.stopped = force ? FORCED_STOP : STOP;
+        },
+        /**
+         * run the recognizers!
+         * called by the inputHandler function on every movement of the pointers (touches)
+         * it walks through all the recognizers and tries to detect the gesture that is being made
+         * @param {Object} inputData
+         */
+        recognize: function(inputData) {
+          var session = this.session;
+          if (session.stopped) {
+            return;
+          }
+          this.touchAction.preventDefaults(inputData);
+          var recognizer;
+          var recognizers = this.recognizers;
+          var curRecognizer = session.curRecognizer;
+          if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) {
+            curRecognizer = session.curRecognizer = null;
+          }
+          var i2 = 0;
+          while (i2 < recognizers.length) {
+            recognizer = recognizers[i2];
+            if (session.stopped !== FORCED_STOP && // 1
+            (!curRecognizer || recognizer == curRecognizer || // 2
+            recognizer.canRecognizeWith(curRecognizer))) {
+              recognizer.recognize(inputData);
             } else {
-              this._timer = setTimeoutContext(function() {
-                this.state = STATE_RECOGNIZED;
-                this.tryEmit();
-              }, options.interval, this);
-              return STATE_BEGAN;
+              recognizer.reset();
+            }
+            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
+              curRecognizer = session.curRecognizer = recognizer;
             }
+            i2++;
           }
-        }
-        return STATE_FAILED;
-      },
-      failTimeout: function() {
-        this._timer = setTimeoutContext(function() {
-          this.state = STATE_FAILED;
-        }, this.options.interval, this);
-        return STATE_FAILED;
-      },
-      reset: function() {
-        clearTimeout(this._timer);
-      },
-      emit: function() {
-        if (this.state == STATE_RECOGNIZED) {
-          this._input.tapCount = this.count;
-          this.manager.emit(this.options.event, this._input);
-        }
-      }
-    });
-    function Hammer2(element, options) {
-      options = options || {};
-      options.recognizers = ifUndefined(options.recognizers, Hammer2.defaults.preset);
-      return new Manager(element, options);
-    }
-    Hammer2.VERSION = "2.0.7";
-    Hammer2.defaults = {
-      /**
-       * set if DOM events are being triggered.
-       * But this is slower and unused by simple implementations, so disabled by default.
-       * @type {Boolean}
-       * @default false
-       */
-      domEvents: false,
-      /**
-       * The value for the touchAction property/fallback.
-       * When set to `compute` it will magically set the correct value based on the added recognizers.
-       * @type {String}
-       * @default compute
-       */
-      touchAction: TOUCH_ACTION_COMPUTE,
-      /**
-       * @type {Boolean}
-       * @default true
-       */
-      enable: true,
-      /**
-       * EXPERIMENTAL FEATURE -- can be removed/changed
-       * Change the parent input target element.
-       * If Null, then it is being set the to main element.
-       * @type {Null|EventTarget}
-       * @default null
-       */
-      inputTarget: null,
-      /**
-       * force an input class
-       * @type {Null|Function}
-       * @default null
-       */
-      inputClass: null,
-      /**
-       * Default recognizer setup when calling `Hammer()`
-       * When creating a new Manager these will be skipped.
-       * @type {Array}
-       */
-      preset: [
-        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
-        [RotateRecognizer, { enable: false }],
-        [PinchRecognizer, { enable: false }, ["rotate"]],
-        [SwipeRecognizer, { direction: DIRECTION_HORIZONTAL }],
-        [PanRecognizer, { direction: DIRECTION_HORIZONTAL }, ["swipe"]],
-        [TapRecognizer],
-        [TapRecognizer, { event: "doubletap", taps: 2 }, ["tap"]],
-        [PressRecognizer]
-      ],
-      /**
-       * Some CSS properties can be used to improve the working of Hammer.
-       * Add them to this method and they will be set when creating a new Manager.
-       * @namespace
-       */
-      cssProps: {
+        },
         /**
-         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
-         * @type {String}
-         * @default 'none'
+         * get a recognizer by its event name.
+         * @param {Recognizer|String} recognizer
+         * @returns {Recognizer|Null}
          */
-        userSelect: "none",
+        get: function(recognizer) {
+          if (recognizer instanceof Recognizer) {
+            return recognizer;
+          }
+          var recognizers = this.recognizers;
+          for (var i2 = 0; i2 < recognizers.length; i2++) {
+            if (recognizers[i2].options.event == recognizer) {
+              return recognizers[i2];
+            }
+          }
+          return null;
+        },
         /**
-         * Disable the Windows Phone grippers when pressing an element.
-         * @type {String}
-         * @default 'none'
+         * add a recognizer to the manager
+         * existing recognizers with the same event name will be removed
+         * @param {Recognizer} recognizer
+         * @returns {Recognizer|Manager}
          */
-        touchSelect: "none",
+        add: function(recognizer) {
+          if (invokeArrayArg(recognizer, "add", this)) {
+            return this;
+          }
+          var existing = this.get(recognizer.options.event);
+          if (existing) {
+            this.remove(existing);
+          }
+          this.recognizers.push(recognizer);
+          recognizer.manager = this;
+          this.touchAction.update();
+          return recognizer;
+        },
         /**
-         * Disables the default callout shown when you touch and hold a touch target.
-         * On iOS, when you touch and hold a touch target such as a link, Safari displays
-         * a callout containing information about the link. This property allows you to disable that callout.
-         * @type {String}
-         * @default 'none'
+         * remove a recognizer by name or instance
+         * @param {Recognizer|String} recognizer
+         * @returns {Manager}
          */
-        touchCallout: "none",
+        remove: function(recognizer) {
+          if (invokeArrayArg(recognizer, "remove", this)) {
+            return this;
+          }
+          recognizer = this.get(recognizer);
+          if (recognizer) {
+            var recognizers = this.recognizers;
+            var index2 = inArray(recognizers, recognizer);
+            if (index2 !== -1) {
+              recognizers.splice(index2, 1);
+              this.touchAction.update();
+            }
+          }
+          return this;
+        },
         /**
-         * Specifies whether zooming is enabled. Used by IE10>
-         * @type {String}
-         * @default 'none'
+         * bind event
+         * @param {String} events
+         * @param {Function} handler
+         * @returns {EventEmitter} this
          */
-        contentZooming: "none",
+        on: function(events, handler) {
+          if (events === undefined$1) {
+            return;
+          }
+          if (handler === undefined$1) {
+            return;
+          }
+          var handlers = this.handlers;
+          each2(splitStr(events), function(event) {
+            handlers[event] = handlers[event] || [];
+            handlers[event].push(handler);
+          });
+          return this;
+        },
         /**
-         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
-         * @type {String}
-         * @default 'none'
+         * unbind event, leave emit blank to remove all handlers
+         * @param {String} events
+         * @param {Function} [handler]
+         * @returns {EventEmitter} this
          */
-        userDrag: "none",
+        off: function(events, handler) {
+          if (events === undefined$1) {
+            return;
+          }
+          var handlers = this.handlers;
+          each2(splitStr(events), function(event) {
+            if (!handler) {
+              delete handlers[event];
+            } else {
+              handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
+            }
+          });
+          return this;
+        },
         /**
-         * Overrides the highlight color shown when the user taps a link or a JavaScript
-         * clickable element in iOS. This property obeys the alpha value, if specified.
-         * @type {String}
-         * @default 'rgba(0,0,0,0)'
+         * emit event to the listeners
+         * @param {String} event
+         * @param {Object} data
          */
-        tapHighlightColor: "rgba(0,0,0,0)"
-      }
-    };
-    var STOP = 1;
-    var FORCED_STOP = 2;
-    function Manager(element, options) {
-      this.options = assign({}, Hammer2.defaults, options || {});
-      this.options.inputTarget = this.options.inputTarget || element;
-      this.handlers = {};
-      this.session = {};
-      this.recognizers = [];
-      this.oldCssProps = {};
-      this.element = element;
-      this.input = createInputInstance(this);
-      this.touchAction = new TouchAction(this, this.options.touchAction);
-      toggleCssProps(this, true);
-      each2(this.options.recognizers, function(item) {
-        var recognizer = this.add(new item[0](item[1]));
-        item[2] && recognizer.recognizeWith(item[2]);
-        item[3] && recognizer.requireFailure(item[3]);
-      }, this);
-    }
-    Manager.prototype = {
-      /**
-       * set options
-       * @param {Object} options
-       * @returns {Manager}
-       */
-      set: function(options) {
-        assign(this.options, options);
-        if (options.touchAction) {
-          this.touchAction.update();
-        }
-        if (options.inputTarget) {
-          this.input.destroy();
-          this.input.target = options.inputTarget;
-          this.input.init();
-        }
-        return this;
-      },
-      /**
-       * stop recognizing for this session.
-       * This session will be discarded, when a new [input]start event is fired.
-       * When forced, the recognizer cycle is stopped immediately.
-       * @param {Boolean} [force]
-       */
-      stop: function(force) {
-        this.session.stopped = force ? FORCED_STOP : STOP;
-      },
-      /**
-       * run the recognizers!
-       * called by the inputHandler function on every movement of the pointers (touches)
-       * it walks through all the recognizers and tries to detect the gesture that is being made
-       * @param {Object} inputData
-       */
-      recognize: function(inputData) {
-        var session = this.session;
-        if (session.stopped) {
-          return;
-        }
-        this.touchAction.preventDefaults(inputData);
-        var recognizer;
-        var recognizers = this.recognizers;
-        var curRecognizer = session.curRecognizer;
-        if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) {
-          curRecognizer = session.curRecognizer = null;
-        }
-        var i2 = 0;
-        while (i2 < recognizers.length) {
-          recognizer = recognizers[i2];
-          if (session.stopped !== FORCED_STOP && // 1
-          (!curRecognizer || recognizer == curRecognizer || // 2
-          recognizer.canRecognizeWith(curRecognizer))) {
-            recognizer.recognize(inputData);
-          } else {
-            recognizer.reset();
+        emit: function(event, data) {
+          if (this.options.domEvents) {
+            triggerDomEvent(event, data);
           }
-          if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
-            curRecognizer = session.curRecognizer = recognizer;
-          }
-          i2++;
-        }
-      },
-      /**
-       * get a recognizer by its event name.
-       * @param {Recognizer|String} recognizer
-       * @returns {Recognizer|Null}
-       */
-      get: function(recognizer) {
-        if (recognizer instanceof Recognizer) {
-          return recognizer;
-        }
-        var recognizers = this.recognizers;
-        for (var i2 = 0; i2 < recognizers.length; i2++) {
-          if (recognizers[i2].options.event == recognizer) {
-            return recognizers[i2];
+          var handlers = this.handlers[event] && this.handlers[event].slice();
+          if (!handlers || !handlers.length) {
+            return;
           }
-        }
-        return null;
-      },
-      /**
-       * add a recognizer to the manager
-       * existing recognizers with the same event name will be removed
-       * @param {Recognizer} recognizer
-       * @returns {Recognizer|Manager}
-       */
-      add: function(recognizer) {
-        if (invokeArrayArg(recognizer, "add", this)) {
-          return this;
-        }
-        var existing = this.get(recognizer.options.event);
-        if (existing) {
-          this.remove(existing);
-        }
-        this.recognizers.push(recognizer);
-        recognizer.manager = this;
-        this.touchAction.update();
-        return recognizer;
-      },
-      /**
-       * remove a recognizer by name or instance
-       * @param {Recognizer|String} recognizer
-       * @returns {Manager}
-       */
-      remove: function(recognizer) {
-        if (invokeArrayArg(recognizer, "remove", this)) {
-          return this;
-        }
-        recognizer = this.get(recognizer);
-        if (recognizer) {
-          var recognizers = this.recognizers;
-          var index2 = inArray(recognizers, recognizer);
-          if (index2 !== -1) {
-            recognizers.splice(index2, 1);
-            this.touchAction.update();
+          data.type = event;
+          data.preventDefault = function() {
+            data.srcEvent.preventDefault();
+          };
+          var i2 = 0;
+          while (i2 < handlers.length) {
+            handlers[i2](data);
+            i2++;
           }
+        },
+        /**
+         * destroy the manager and unbinds all events
+         * it doesn't unbind dom events, that is the user own responsibility
+         */
+        destroy: function() {
+          this.element && toggleCssProps(this, false);
+          this.handlers = {};
+          this.session = {};
+          this.input.destroy();
+          this.element = null;
         }
-        return this;
-      },
-      /**
-       * bind event
-       * @param {String} events
-       * @param {Function} handler
-       * @returns {EventEmitter} this
-       */
-      on: function(events, handler) {
-        if (events === undefined$1) {
-          return;
-        }
-        if (handler === undefined$1) {
-          return;
-        }
-        var handlers = this.handlers;
-        each2(splitStr(events), function(event) {
-          handlers[event] = handlers[event] || [];
-          handlers[event].push(handler);
-        });
-        return this;
-      },
-      /**
-       * unbind event, leave emit blank to remove all handlers
-       * @param {String} events
-       * @param {Function} [handler]
-       * @returns {EventEmitter} this
-       */
-      off: function(events, handler) {
-        if (events === undefined$1) {
+      };
+      function toggleCssProps(manager, add2) {
+        var element = manager.element;
+        if (!element.style) {
           return;
         }
-        var handlers = this.handlers;
-        each2(splitStr(events), function(event) {
-          if (!handler) {
-            delete handlers[event];
+        var prop;
+        each2(manager.options.cssProps, function(value, name) {
+          prop = prefixed(element.style, name);
+          if (add2) {
+            manager.oldCssProps[prop] = element.style[prop];
+            element.style[prop] = value;
           } else {
-            handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
+            element.style[prop] = manager.oldCssProps[prop] || "";
           }
         });
-        return this;
-      },
-      /**
-       * emit event to the listeners
-       * @param {String} event
-       * @param {Object} data
-       */
-      emit: function(event, data) {
-        if (this.options.domEvents) {
-          triggerDomEvent(event, data);
-        }
-        var handlers = this.handlers[event] && this.handlers[event].slice();
-        if (!handlers || !handlers.length) {
-          return;
-        }
-        data.type = event;
-        data.preventDefault = function() {
-          data.srcEvent.preventDefault();
-        };
-        var i2 = 0;
-        while (i2 < handlers.length) {
-          handlers[i2](data);
-          i2++;
+        if (!add2) {
+          manager.oldCssProps = {};
         }
-      },
-      /**
-       * destroy the manager and unbinds all events
-       * it doesn't unbind dom events, that is the user own responsibility
-       */
-      destroy: function() {
-        this.element && toggleCssProps(this, false);
-        this.handlers = {};
-        this.session = {};
-        this.input.destroy();
-        this.element = null;
-      }
-    };
-    function toggleCssProps(manager, add2) {
-      var element = manager.element;
-      if (!element.style) {
-        return;
       }
-      var prop;
-      each2(manager.options.cssProps, function(value, name) {
-        prop = prefixed(element.style, name);
-        if (add2) {
-          manager.oldCssProps[prop] = element.style[prop];
-          element.style[prop] = value;
-        } else {
-          element.style[prop] = manager.oldCssProps[prop] || "";
-        }
+      function triggerDomEvent(event, data) {
+        var gestureEvent = document2.createEvent("Event");
+        gestureEvent.initEvent(event, true, true);
+        gestureEvent.gesture = data;
+        data.target.dispatchEvent(gestureEvent);
+      }
+      assign(Hammer2, {
+        INPUT_START,
+        INPUT_MOVE,
+        INPUT_END,
+        INPUT_CANCEL,
+        STATE_POSSIBLE,
+        STATE_BEGAN,
+        STATE_CHANGED,
+        STATE_ENDED,
+        STATE_RECOGNIZED,
+        STATE_CANCELLED,
+        STATE_FAILED,
+        DIRECTION_NONE,
+        DIRECTION_LEFT,
+        DIRECTION_RIGHT,
+        DIRECTION_UP,
+        DIRECTION_DOWN,
+        DIRECTION_HORIZONTAL,
+        DIRECTION_VERTICAL,
+        DIRECTION_ALL,
+        Manager,
+        Input,
+        TouchAction,
+        TouchInput,
+        MouseInput,
+        PointerEventInput,
+        TouchMouseInput,
+        SingleTouchInput,
+        Recognizer,
+        AttrRecognizer,
+        Tap: TapRecognizer,
+        Pan: PanRecognizer,
+        Swipe: SwipeRecognizer,
+        Pinch: PinchRecognizer,
+        Rotate: RotateRecognizer,
+        Press: PressRecognizer,
+        on: addEventListeners,
+        off: removeEventListeners,
+        each: each2,
+        merge: merge2,
+        extend,
+        assign,
+        inherit,
+        bindFn,
+        prefixed
       });
-      if (!add2) {
-        manager.oldCssProps = {};
-      }
-    }
-    function triggerDomEvent(event, data) {
-      var gestureEvent = document2.createEvent("Event");
-      gestureEvent.initEvent(event, true, true);
-      gestureEvent.gesture = data;
-      data.target.dispatchEvent(gestureEvent);
-    }
-    assign(Hammer2, {
-      INPUT_START,
-      INPUT_MOVE,
-      INPUT_END,
-      INPUT_CANCEL,
-      STATE_POSSIBLE,
-      STATE_BEGAN,
-      STATE_CHANGED,
-      STATE_ENDED,
-      STATE_RECOGNIZED,
-      STATE_CANCELLED,
-      STATE_FAILED,
-      DIRECTION_NONE,
-      DIRECTION_LEFT,
-      DIRECTION_RIGHT,
-      DIRECTION_UP,
-      DIRECTION_DOWN,
-      DIRECTION_HORIZONTAL,
-      DIRECTION_VERTICAL,
-      DIRECTION_ALL,
-      Manager,
-      Input,
-      TouchAction,
-      TouchInput,
-      MouseInput,
-      PointerEventInput,
-      TouchMouseInput,
-      SingleTouchInput,
-      Recognizer,
-      AttrRecognizer,
-      Tap: TapRecognizer,
-      Pan: PanRecognizer,
-      Swipe: SwipeRecognizer,
-      Pinch: PinchRecognizer,
-      Rotate: RotateRecognizer,
-      Press: PressRecognizer,
-      on: addEventListeners,
-      off: removeEventListeners,
-      each: each2,
-      merge: merge2,
-      extend,
-      assign,
-      inherit,
-      bindFn,
-      prefixed
-    });
-    var freeGlobal = typeof window2 !== "undefined" ? window2 : typeof self !== "undefined" ? self : {};
-    freeGlobal.Hammer = Hammer2;
-    if (module.exports) {
-      module.exports = Hammer2;
-    } else {
-      window2[exportName] = Hammer2;
-    }
-  })(window, document, "Hammer");
-})(hammer);
-var hammerExports = hammer.exports;
+      var freeGlobal = typeof window2 !== "undefined" ? window2 : typeof self !== "undefined" ? self : {};
+      freeGlobal.Hammer = Hammer2;
+      if (module.exports) {
+        module.exports = Hammer2;
+      } else {
+        window2[exportName] = Hammer2;
+      }
+    })(window, document, "Hammer");
+  })(hammer);
+  return hammer.exports;
+}
+var hammerExports = requireHammer();
 const Hammer = /* @__PURE__ */ getDefaultExportFromCjs(hammerExports);
 /*!
-* chartjs-plugin-zoom v2.2.0
-* https://www.chartjs.org/chartjs-plugin-zoom/2.2.0/
- * (c) 2016-2024 chartjs-plugin-zoom Contributors
+* chartjs-plugin-zoom v2.0.1
+* undefined
+ * (c) 2016-2023 chartjs-plugin-zoom Contributors
  * Released under the MIT License
  */
 const getModifierKey = (opts) => opts && opts.enabled && opts.modifierKey;
@@ -15000,9 +15033,7 @@ function getState(chart2) {
       originalScaleLimits: {},
       updatedScaleLimits: {},
       handlers: {},
-      panDelta: {},
-      dragging: false,
-      panning: false
+      panDelta: {}
     };
     chartStates$1.set(chart2, state);
   }
@@ -15011,43 +15042,20 @@ function getState(chart2) {
 function removeState(chart2) {
   chartStates$1.delete(chart2);
 }
-function zoomDelta(val, min, range, newRange) {
-  const minPercent = Math.max(0, Math.min(1, (val - min) / range || 0));
+function zoomDelta(scale, zoom2, center) {
+  const range = scale.max - scale.min;
+  const newRange = range * (zoom2 - 1);
+  const centerPoint = scale.isHorizontal() ? center.x : center.y;
+  const minPercent = Math.max(0, Math.min(
+    1,
+    (scale.getValueForPixel(centerPoint) - scale.min) / range || 0
+  ));
   const maxPercent = 1 - minPercent;
   return {
     min: newRange * minPercent,
     max: newRange * maxPercent
   };
 }
-function getValueAtPoint(scale, point) {
-  const pixel = scale.isHorizontal() ? point.x : point.y;
-  return scale.getValueForPixel(pixel);
-}
-function linearZoomDelta(scale, zoom2, center) {
-  const range = scale.max - scale.min;
-  const newRange = range * (zoom2 - 1);
-  const centerValue = getValueAtPoint(scale, center);
-  return zoomDelta(centerValue, scale.min, range, newRange);
-}
-function logarithmicZoomRange(scale, zoom2, center) {
-  const centerValue = getValueAtPoint(scale, center);
-  if (centerValue === void 0) {
-    return { min: scale.min, max: scale.max };
-  }
-  const logMin = Math.log10(scale.min);
-  const logMax = Math.log10(scale.max);
-  const logCenter = Math.log10(centerValue);
-  const logRange = logMax - logMin;
-  const newLogRange = logRange * (zoom2 - 1);
-  const delta = zoomDelta(logCenter, logMin, logRange, newLogRange);
-  return {
-    min: Math.pow(10, logMin + delta.min),
-    max: Math.pow(10, logMax - delta.max)
-  };
-}
-function getScaleLimits$1(scale, limits) {
-  return limits && (limits[scale.id] || limits[scale.axis]) || {};
-}
 function getLimit(state, scale, scaleLimits, prop, fallback) {
   let limit = scaleLimits[prop];
   if (limit === "original") {
@@ -15056,7 +15064,7 @@ function getLimit(state, scale, scaleLimits, prop, fallback) {
   }
   return valueOrDefault$1(limit, fallback);
 }
-function linearRange(scale, pixel0, pixel1) {
+function getRange(scale, pixel0, pixel1) {
   const v0 = scale.getValueForPixel(pixel0);
   const v1 = scale.getValueForPixel(pixel1);
   return {
@@ -15064,19 +15072,17 @@ function linearRange(scale, pixel0, pixel1) {
     max: Math.max(v0, v1)
   };
 }
-function fixRange(range, { min, max, minLimit, maxLimit }, originalLimits) {
+function updateRange(scale, { min, max }, limits, zoom2 = false) {
+  const state = getState(scale.chart);
+  const { id, axis, options: scaleOpts } = scale;
+  const scaleLimits = limits && (limits[id] || limits[axis]) || {};
+  const { minRange = 0 } = scaleLimits;
+  const minLimit = getLimit(state, scale, scaleLimits, "min", -Infinity);
+  const maxLimit = getLimit(state, scale, scaleLimits, "max", Infinity);
+  const range = zoom2 ? Math.max(max - min, minRange) : scale.max - scale.min;
   const offset = (range - max + min) / 2;
   min -= offset;
   max += offset;
-  const origMin = originalLimits.min.options ?? originalLimits.min.scale;
-  const origMax = originalLimits.max.options ?? originalLimits.max.scale;
-  const epsilon = range / 1e6;
-  if (almostEquals$1(min, origMin, epsilon)) {
-    min = origMin;
-  }
-  if (almostEquals$1(max, origMax, epsilon)) {
-    max = origMax;
-  }
   if (min < minLimit) {
     min = minLimit;
     max = Math.min(minLimit + range, maxLimit);
@@ -15084,40 +15090,18 @@ function fixRange(range, { min, max, minLimit, maxLimit }, originalLimits) {
     max = maxLimit;
     min = Math.max(maxLimit - range, minLimit);
   }
-  return { min, max };
-}
-function updateRange(scale, { min, max }, limits, zoom2 = false) {
-  const state = getState(scale.chart);
-  const { options: scaleOpts } = scale;
-  const scaleLimits = getScaleLimits$1(scale, limits);
-  const { minRange = 0 } = scaleLimits;
-  const minLimit = getLimit(state, scale, scaleLimits, "min", -Infinity);
-  const maxLimit = getLimit(state, scale, scaleLimits, "max", Infinity);
-  if (zoom2 === "pan" && (min < minLimit || max > maxLimit)) {
-    return true;
-  }
-  const scaleRange = scale.max - scale.min;
-  const range = zoom2 ? Math.max(max - min, minRange) : scaleRange;
-  if (zoom2 && range === minRange && scaleRange <= minRange) {
-    return true;
-  }
-  const newRange = fixRange(range, { min, max, minLimit, maxLimit }, state.originalScaleLimits[scale.id]);
-  scaleOpts.min = newRange.min;
-  scaleOpts.max = newRange.max;
-  state.updatedScaleLimits[scale.id] = newRange;
-  return scale.parse(newRange.min) !== scale.min || scale.parse(newRange.max) !== scale.max;
+  scaleOpts.min = min;
+  scaleOpts.max = max;
+  state.updatedScaleLimits[scale.id] = { min, max };
+  return scale.parse(min) !== scale.min || scale.parse(max) !== scale.max;
 }
 function zoomNumericalScale(scale, zoom2, center, limits) {
-  const delta = linearZoomDelta(scale, zoom2, center);
+  const delta = zoomDelta(scale, zoom2, center);
   const newRange = { min: scale.min + delta.min, max: scale.max - delta.max };
   return updateRange(scale, newRange, limits, true);
 }
-function zoomLogarithmicScale(scale, zoom2, center, limits) {
-  const newRange = logarithmicZoomRange(scale, zoom2, center);
-  return updateRange(scale, newRange, limits, true);
-}
 function zoomRectNumericalScale(scale, from2, to2, limits) {
-  updateRange(scale, linearRange(scale, from2, to2), limits, true);
+  updateRange(scale, getRange(scale, from2, to2), limits, true);
 }
 const integerChange = (v2) => v2 === 0 || isNaN(v2) ? 0 : v2 < 0 ? Math.min(Math.round(v2), -1) : Math.max(Math.round(v2), 1);
 function existCategoryFromMaxZoom(scale) {
@@ -15131,7 +15115,7 @@ function existCategoryFromMaxZoom(scale) {
   }
 }
 function zoomCategoryScale(scale, zoom2, center, limits) {
-  const delta = linearZoomDelta(scale, zoom2, center);
+  const delta = zoomDelta(scale, zoom2, center);
   if (scale.min === scale.max && zoom2 < 1) {
     existCategoryFromMaxZoom(scale);
   }
@@ -15162,32 +15146,40 @@ function panCategoryScale(scale, delta, limits) {
 }
 const OFFSETS = {
   second: 500,
+  // 500 ms
   minute: 30 * 1e3,
+  // 30 s
   hour: 30 * 60 * 1e3,
+  // 30 m
   day: 12 * 60 * 60 * 1e3,
+  // 12 h
   week: 3.5 * 24 * 60 * 60 * 1e3,
+  // 3.5 d
   month: 15 * 24 * 60 * 60 * 1e3,
+  // 15 d
   quarter: 60 * 24 * 60 * 60 * 1e3,
+  // 60 d
   year: 182 * 24 * 60 * 60 * 1e3
+  // 182 d
 };
-function panNumericalScale(scale, delta, limits, pan2 = false) {
+function panNumericalScale(scale, delta, limits, canZoom = false) {
   const { min: prevStart, max: prevEnd, options } = scale;
   const round2 = options.time && options.time.round;
   const offset = OFFSETS[round2] || 0;
   const newMin = scale.getValueForPixel(scale.getPixelForValue(prevStart + offset) - delta);
   const newMax = scale.getValueForPixel(scale.getPixelForValue(prevEnd + offset) - delta);
-  if (isNaN(newMin) || isNaN(newMax)) {
+  const { min: minLimit = -Infinity, max: maxLimit = Infinity } = canZoom && limits && limits[scale.axis] || {};
+  if (isNaN(newMin) || isNaN(newMax) || newMin < minLimit || newMax > maxLimit) {
     return true;
   }
-  return updateRange(scale, { min: newMin, max: newMax }, limits, pan2 ? "pan" : false);
+  return updateRange(scale, { min: newMin, max: newMax }, limits, canZoom);
 }
 function panNonLinearScale(scale, delta, limits) {
   return panNumericalScale(scale, delta, limits, true);
 }
 const zoomFunctions = {
   category: zoomCategoryScale,
-  default: zoomNumericalScale,
-  logarithmic: zoomLogarithmicScale
+  default: zoomNumericalScale
 };
 const zoomRectFunctions = {
   default: zoomRectNumericalScale
@@ -15232,9 +15224,9 @@ function doZoom(scale, amount, center, limits) {
   const fn = zoomFunctions[scale.type] || zoomFunctions.default;
   callback$1(fn, [scale, amount, center, limits]);
 }
-function doZoomRect(scale, from2, to2, limits) {
+function doZoomRect(scale, amount, from2, to2, limits) {
   const fn = zoomRectFunctions[scale.type] || zoomRectFunctions.default;
-  callback$1(fn, [scale, from2, to2, limits]);
+  callback$1(fn, [scale, amount, from2, to2, limits]);
 }
 function getCenter(chart2) {
   const ca = chart2.chartArea;
@@ -15243,7 +15235,7 @@ function getCenter(chart2) {
     y: (ca.top + ca.bottom) / 2
   };
 }
-function zoom(chart2, amount, transition = "none", trigger = "api") {
+function zoom(chart2, amount, transition = "none") {
   const { x: x2 = 1, y: y2 = 1, focalPoint = getCenter(chart2) } = typeof amount === "number" ? { x: amount, y: amount } : amount;
   const state = getState(chart2);
   const { options: { limits, zoom: zoomOptions } } = state;
@@ -15259,9 +15251,9 @@ function zoom(chart2, amount, transition = "none", trigger = "api") {
     }
   });
   chart2.update(transition);
-  callback$1(zoomOptions.onZoom, [{ chart: chart2, trigger }]);
+  callback$1(zoomOptions.onZoom, [{ chart: chart2 }]);
 }
-function zoomRect(chart2, p0, p1, transition = "none", trigger = "api") {
+function zoomRect(chart2, p0, p1, transition = "none") {
   const state = getState(chart2);
   const { options: { limits, zoom: zoomOptions } } = state;
   const { mode = "xy" } = zoomOptions;
@@ -15276,16 +15268,13 @@ function zoomRect(chart2, p0, p1, transition = "none", trigger = "api") {
     }
   });
   chart2.update(transition);
-  callback$1(zoomOptions.onZoom, [{ chart: chart2, trigger }]);
+  callback$1(zoomOptions.onZoom, [{ chart: chart2 }]);
 }
-function zoomScale(chart2, scaleId, range, transition = "none", trigger = "api") {
-  var _a2;
-  const state = getState(chart2);
-  storeOriginalScaleLimits(chart2, state);
+function zoomScale(chart2, scaleId, range, transition = "none") {
+  storeOriginalScaleLimits(chart2, getState(chart2));
   const scale = chart2.scales[scaleId];
   updateRange(scale, range, void 0, true);
   chart2.update(transition);
-  callback$1((_a2 = state.options.zoom) == null ? void 0 : _a2.onZoom, [{ chart: chart2, trigger }]);
 }
 function resetZoom(chart2, transition = "default") {
   const state = getState(chart2);
@@ -15299,7 +15288,6 @@ function resetZoom(chart2, transition = "default") {
       delete scaleOptions.min;
       delete scaleOptions.max;
     }
-    delete state.updatedScaleLimits[scale.id];
   });
   chart2.update(transition);
   callback$1(state.options.zoom.onZoomComplete, [{ chart: chart2 }]);
@@ -15367,14 +15355,6 @@ function getInitialScaleBounds(chart2) {
   }
   return scaleBounds;
 }
-function getZoomedScaleBounds(chart2) {
-  const state = getState(chart2);
-  const scaleBounds = {};
-  for (const scaleId of Object.keys(chart2.scales)) {
-    scaleBounds[scaleId] = state.updatedScaleLimits[scaleId];
-  }
-  return scaleBounds;
-}
 function isZoomedOrPanned(chart2) {
   const scaleBounds = getInitialScaleBounds(chart2);
   for (const scaleId of Object.keys(chart2.scales)) {
@@ -15388,11 +15368,6 @@ function isZoomedOrPanned(chart2) {
   }
   return false;
 }
-function isZoomingOrPanning(chart2) {
-  const state = getState(chart2);
-  return state.panning || state.dragging;
-}
-const clamp$1 = (x2, from2, to2) => Math.min(to2, Math.max(from2, x2));
 function removeHandler(chart2, type) {
   const { handlers } = getState(chart2);
   const handler = handlers[type];
@@ -15410,8 +15385,7 @@ function addHandler(chart2, target, type, handler) {
   removeHandler(chart2, type);
   handlers[type] = (event) => handler(chart2, event, options);
   handlers[type].target = target;
-  const passive = type === "wheel" ? false : void 0;
-  target.addEventListener(type, handlers[type], { passive });
+  target.addEventListener(type, handlers[type]);
 }
 function mouseMove(chart2, event) {
   const state = getState(chart2);
@@ -15431,20 +15405,10 @@ function keyDown(chart2, event) {
   state.dragStart = state.dragEnd = null;
   chart2.update("none");
 }
-function getPointPosition(event, chart2) {
-  if (event.target !== chart2.canvas) {
-    const canvasArea = chart2.canvas.getBoundingClientRect();
-    return {
-      x: event.clientX - canvasArea.left,
-      y: event.clientY - canvasArea.top
-    };
-  }
-  return getRelativePosition$2(event, chart2);
-}
 function zoomStart(chart2, event, zoomOptions) {
   const { onZoomStart, onZoomRejected } = zoomOptions;
   if (onZoomStart) {
-    const point = getPointPosition(event, chart2);
+    const point = getRelativePosition$2(event, chart2);
     if (callback$1(onZoomStart, [{ chart: chart2, event, point }]) === false) {
       callback$1(onZoomRejected, [{ chart: chart2, event }]);
       return false;
@@ -15452,12 +15416,6 @@ function zoomStart(chart2, event, zoomOptions) {
   }
 }
 function mouseDown(chart2, event) {
-  if (chart2.legend) {
-    const point = getRelativePosition$2(event, chart2);
-    if (_isPointInArea$1(point, chart2.legend)) {
-      return;
-    }
-  }
   const state = getState(chart2);
   const { pan: panOptions, zoom: zoomOptions = {} } = state.options;
   if (event.button !== 0 || keyPressed(getModifierKey(panOptions), event) || keyNotPressed(getModifierKey(zoomOptions.drag), event)) {
@@ -15467,52 +15425,30 @@ function mouseDown(chart2, event) {
     return;
   }
   state.dragStart = event;
-  addHandler(chart2, chart2.canvas.ownerDocument, "mousemove", mouseMove);
+  addHandler(chart2, chart2.canvas, "mousemove", mouseMove);
   addHandler(chart2, window.document, "keydown", keyDown);
 }
-function applyAspectRatio({ begin, end }, aspectRatio) {
-  let width = end.x - begin.x;
-  let height = end.y - begin.y;
-  const ratio = Math.abs(width / height);
-  if (ratio > aspectRatio) {
-    width = Math.sign(width) * Math.abs(height * aspectRatio);
-  } else if (ratio < aspectRatio) {
-    height = Math.sign(height) * Math.abs(width / aspectRatio);
-  }
-  end.x = begin.x + width;
-  end.y = begin.y + height;
-}
-function applyMinMaxProps(rect, chartArea, points, { min, max, prop }) {
-  rect[min] = clamp$1(Math.min(points.begin[prop], points.end[prop]), chartArea[min], chartArea[max]);
-  rect[max] = clamp$1(Math.max(points.begin[prop], points.end[prop]), chartArea[min], chartArea[max]);
-}
-function getRelativePoints(chart2, pointEvents, maintainAspectRatio) {
-  const points = {
-    begin: getPointPosition(pointEvents.dragStart, chart2),
-    end: getPointPosition(pointEvents.dragEnd, chart2)
-  };
-  if (maintainAspectRatio) {
-    const aspectRatio = chart2.chartArea.width / chart2.chartArea.height;
-    applyAspectRatio(points, aspectRatio);
-  }
-  return points;
-}
-function computeDragRect(chart2, mode, pointEvents, maintainAspectRatio) {
+function computeDragRect(chart2, mode, beginPointEvent, endPointEvent) {
   const xEnabled = directionEnabled(mode, "x", chart2);
   const yEnabled = directionEnabled(mode, "y", chart2);
-  const { top: top2, left: left2, right: right2, bottom: bottom2, width: chartWidth, height: chartHeight } = chart2.chartArea;
-  const rect = { top: top2, left: left2, right: right2, bottom: bottom2 };
-  const points = getRelativePoints(chart2, pointEvents, maintainAspectRatio && xEnabled && yEnabled);
+  let { top: top2, left: left2, right: right2, bottom: bottom2, width: chartWidth, height: chartHeight } = chart2.chartArea;
+  const beginPoint = getRelativePosition$2(beginPointEvent, chart2);
+  const endPoint = getRelativePosition$2(endPointEvent, chart2);
   if (xEnabled) {
-    applyMinMaxProps(rect, chart2.chartArea, points, { min: "left", max: "right", prop: "x" });
+    left2 = Math.min(beginPoint.x, endPoint.x);
+    right2 = Math.max(beginPoint.x, endPoint.x);
   }
   if (yEnabled) {
-    applyMinMaxProps(rect, chart2.chartArea, points, { min: "top", max: "bottom", prop: "y" });
+    top2 = Math.min(beginPoint.y, endPoint.y);
+    bottom2 = Math.max(beginPoint.y, endPoint.y);
   }
-  const width = rect.right - rect.left;
-  const height = rect.bottom - rect.top;
+  const width = right2 - left2;
+  const height = bottom2 - top2;
   return {
-    ...rect,
+    left: left2,
+    top: top2,
+    right: right2,
+    bottom: bottom2,
     width,
     height,
     zoomX: xEnabled && width ? 1 + (chartWidth - width) / chartWidth : 1,
@@ -15525,8 +15461,8 @@ function mouseUp(chart2, event) {
     return;
   }
   removeHandler(chart2, "mousemove");
-  const { mode, onZoomComplete, drag: { threshold = 0, maintainAspectRatio } } = state.options.zoom;
-  const rect = computeDragRect(chart2, mode, { dragStart: state.dragStart, dragEnd: event }, maintainAspectRatio);
+  const { mode, onZoomComplete, drag: { threshold = 0 } } = state.options.zoom;
+  const rect = computeDragRect(chart2, mode, state.dragStart, event);
   const distanceX = directionEnabled(mode, "x", chart2) ? rect.width : 0;
   const distanceY = directionEnabled(mode, "y", chart2) ? rect.height : 0;
   const distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY);
@@ -15536,9 +15472,8 @@ function mouseUp(chart2, event) {
     chart2.update("none");
     return;
   }
-  zoomRect(chart2, { x: rect.left, y: rect.top }, { x: rect.right, y: rect.bottom }, "zoom", "drag");
-  state.dragging = false;
-  state.filterNextClick = true;
+  zoomRect(chart2, { x: rect.left, y: rect.top }, { x: rect.right, y: rect.bottom }, "zoom");
+  setTimeout(() => state.dragging = false, 500);
   callback$1(onZoomComplete, [{ chart: chart2 }]);
 }
 function wheelPreconditions(chart2, event, zoomOptions) {
@@ -15563,18 +15498,19 @@ function wheel(chart2, event) {
     return;
   }
   const rect = event.target.getBoundingClientRect();
-  const speed = zoomOptions.wheel.speed;
-  const percentage = event.deltaY >= 0 ? 2 - 1 / (1 - speed) : 1 + speed;
+  const speed = 1 + (event.deltaY >= 0 ? -zoomOptions.wheel.speed : zoomOptions.wheel.speed);
   const amount = {
-    x: percentage,
-    y: percentage,
+    x: speed,
+    y: speed,
     focalPoint: {
       x: event.clientX - rect.left,
       y: event.clientY - rect.top
     }
   };
-  zoom(chart2, amount, "zoom", "wheel");
-  callback$1(onZoomComplete, [{ chart: chart2 }]);
+  zoom(chart2, amount);
+  if (onZoomComplete) {
+    onZoomComplete();
+  }
 }
 function addDebouncedHandler(chart2, name, handler, delay) {
   if (handler) {
@@ -15654,19 +15590,13 @@ function handlePinch(chart2, state, e2) {
         y: center.y - rect.top
       }
     };
-    zoom(chart2, amount, "zoom", "pinch");
+    zoom(chart2, amount);
     state.scale = e2.scale;
   }
 }
-function startPinch(chart2, state, event) {
+function startPinch(chart2, state) {
   if (state.options.zoom.pinch.enabled) {
-    const point = getRelativePosition$2(event, chart2);
-    if (callback$1(state.options.zoom.onZoomStart, [{ chart: chart2, event, point }]) === false) {
-      state.scale = null;
-      callback$1(state.options.zoom.onZoomRejected, [{ chart: chart2, event }]);
-    } else {
-      state.scale = 1;
-    }
+    state.scale = 1;
   }
 }
 function endPinch(chart2, state, e2) {
@@ -15699,13 +15629,13 @@ function startPan(chart2, state, event) {
   }
   state.panScales = getEnabledScalesByPoint(state.options.pan, point, chart2);
   state.delta = { x: 0, y: 0 };
+  clearTimeout(state.panEndTimeout);
   handlePan(chart2, state, event);
 }
 function endPan(chart2, state) {
   state.delta = null;
   if (state.panning) {
-    state.panning = false;
-    state.filterNextClick = true;
+    state.panEndTimeout = setTimeout(() => state.panning = false, 500);
     callback$1(state.options.pan.onPanComplete, [{ chart: chart2 }]);
   }
 }
@@ -15717,7 +15647,7 @@ function startHammer(chart2, options) {
   const mc = new Hammer.Manager(canvas2);
   if (zoomOptions && zoomOptions.pinch.enabled) {
     mc.add(new Hammer.Pinch());
-    mc.on("pinchstart", (e2) => startPinch(chart2, state, e2));
+    mc.on("pinchstart", () => startPinch(chart2, state));
     mc.on("pinch", (e2) => handlePinch(chart2, state, e2));
     mc.on("pinchend", (e2) => endPinch(chart2, state, e2));
   }
@@ -15745,29 +15675,14 @@ function stopHammer(chart2) {
     hammers.delete(chart2);
   }
 }
-function hammerOptionsChanged(oldOptions, newOptions) {
-  var _a2, _b2, _c2, _d2;
-  const { pan: oldPan, zoom: oldZoom } = oldOptions;
-  const { pan: newPan, zoom: newZoom } = newOptions;
-  if (((_b2 = (_a2 = oldZoom == null ? void 0 : oldZoom.zoom) == null ? void 0 : _a2.pinch) == null ? void 0 : _b2.enabled) !== ((_d2 = (_c2 = newZoom == null ? void 0 : newZoom.zoom) == null ? void 0 : _c2.pinch) == null ? void 0 : _d2.enabled)) {
-    return true;
-  }
-  if ((oldPan == null ? void 0 : oldPan.enabled) !== (newPan == null ? void 0 : newPan.enabled)) {
-    return true;
-  }
-  if ((oldPan == null ? void 0 : oldPan.threshold) !== (newPan == null ? void 0 : newPan.threshold)) {
-    return true;
-  }
-  return false;
-}
-var version$2 = "2.2.0";
+var version$2 = "2.0.1";
 function draw$2(chart2, caller, options) {
   const dragOptions = options.zoom.drag;
   const { dragStart, dragEnd } = getState(chart2);
   if (dragOptions.drawTime !== caller || !dragEnd) {
     return;
   }
-  const { left: left2, top: top2, width, height } = computeDragRect(chart2, options.zoom.mode, { dragStart, dragEnd }, dragOptions.maintainAspectRatio);
+  const { left: left2, top: top2, width, height } = computeDragRect(chart2, options.zoom.mode, dragStart, dragEnd);
   const ctx = chart2.ctx;
   ctx.save();
   ctx.beginPath();
@@ -15826,30 +15741,17 @@ var plugin$1 = {
     chart2.resetZoom = (transition) => resetZoom(chart2, transition);
     chart2.getZoomLevel = () => getZoomLevel(chart2);
     chart2.getInitialScaleBounds = () => getInitialScaleBounds(chart2);
-    chart2.getZoomedScaleBounds = () => getZoomedScaleBounds(chart2);
     chart2.isZoomedOrPanned = () => isZoomedOrPanned(chart2);
-    chart2.isZoomingOrPanning = () => isZoomingOrPanning(chart2);
   },
-  beforeEvent(chart2, { event }) {
-    if (isZoomingOrPanning(chart2)) {
+  beforeEvent(chart2) {
+    const state = getState(chart2);
+    if (state.panning || state.dragging) {
       return false;
     }
-    if (event.type === "click" || event.type === "mouseup") {
-      const state = getState(chart2);
-      if (state.filterNextClick) {
-        state.filterNextClick = false;
-        return false;
-      }
-    }
   },
   beforeUpdate: function(chart2, args, options) {
     const state = getState(chart2);
-    const previousOptions = state.options;
     state.options = options;
-    if (hammerOptionsChanged(previousOptions, options)) {
-      stopHammer(chart2);
-      startHammer(chart2, options);
-    }
     addListeners(chart2, options);
   },
   beforeDatasetsDraw(chart2, _args, options) {
@@ -17363,6 +17265,7 @@ function drawPointStyle(ctx, { x: x2, y: y2, radius, rotation, style, rad }) {
   let xOffset, yOffset, size, cornerRadius;
   ctx.beginPath();
   switch (style) {
+    // Default includes circle
     default:
       ctx.arc(x2, y2, radius, 0, TAU$1);
       ctx.closePath();
@@ -17393,6 +17296,7 @@ function drawPointStyle(ctx, { x: x2, y: y2, radius, rotation, style, rad }) {
         break;
       }
       rad += QUARTER_PI$1;
+    /* falls through */
     case "rectRot":
       xOffset = Math.cos(rad) * radius;
       yOffset = Math.sin(rad) * radius;
@@ -17404,6 +17308,7 @@ function drawPointStyle(ctx, { x: x2, y: y2, radius, rotation, style, rad }) {
       break;
     case "crossRot":
       rad += QUARTER_PI$1;
+    /* falls through */
     case "cross":
       xOffset = Math.cos(rad) * radius;
       yOffset = Math.sin(rad) * radius;
@@ -20784,35 +20689,43 @@ function createSingletonDndContext(backend, context = getGlobalContext(), option
 function getGlobalContext() {
   return typeof global !== "undefined" ? global : window;
 }
-var fastDeepEqual = function equal(a2, b2) {
-  if (a2 === b2) return true;
-  if (a2 && b2 && typeof a2 == "object" && typeof b2 == "object") {
-    if (a2.constructor !== b2.constructor) return false;
-    var length, i2, keys;
-    if (Array.isArray(a2)) {
-      length = a2.length;
-      if (length != b2.length) return false;
+var fastDeepEqual;
+var hasRequiredFastDeepEqual;
+function requireFastDeepEqual() {
+  if (hasRequiredFastDeepEqual) return fastDeepEqual;
+  hasRequiredFastDeepEqual = 1;
+  fastDeepEqual = function equal(a2, b2) {
+    if (a2 === b2) return true;
+    if (a2 && b2 && typeof a2 == "object" && typeof b2 == "object") {
+      if (a2.constructor !== b2.constructor) return false;
+      var length, i2, keys;
+      if (Array.isArray(a2)) {
+        length = a2.length;
+        if (length != b2.length) return false;
+        for (i2 = length; i2-- !== 0; )
+          if (!equal(a2[i2], b2[i2])) return false;
+        return true;
+      }
+      if (a2.constructor === RegExp) return a2.source === b2.source && a2.flags === b2.flags;
+      if (a2.valueOf !== Object.prototype.valueOf) return a2.valueOf() === b2.valueOf();
+      if (a2.toString !== Object.prototype.toString) return a2.toString() === b2.toString();
+      keys = Object.keys(a2);
+      length = keys.length;
+      if (length !== Object.keys(b2).length) return false;
       for (i2 = length; i2-- !== 0; )
-        if (!equal(a2[i2], b2[i2])) return false;
+        if (!Object.prototype.hasOwnProperty.call(b2, keys[i2])) return false;
+      for (i2 = length; i2-- !== 0; ) {
+        var key = keys[i2];
+        if (!equal(a2[key], b2[key])) return false;
+      }
       return true;
     }
-    if (a2.constructor === RegExp) return a2.source === b2.source && a2.flags === b2.flags;
-    if (a2.valueOf !== Object.prototype.valueOf) return a2.valueOf() === b2.valueOf();
-    if (a2.toString !== Object.prototype.toString) return a2.toString() === b2.toString();
-    keys = Object.keys(a2);
-    length = keys.length;
-    if (length !== Object.keys(b2).length) return false;
-    for (i2 = length; i2-- !== 0; )
-      if (!Object.prototype.hasOwnProperty.call(b2, keys[i2])) return false;
-    for (i2 = length; i2-- !== 0; ) {
-      var key = keys[i2];
-      if (!equal(a2[key], b2[key])) return false;
-    }
-    return true;
-  }
-  return a2 !== a2 && b2 !== b2;
-};
-const isEqual = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqual);
+    return a2 !== a2 && b2 !== b2;
+  };
+  return fastDeepEqual;
+}
+var fastDeepEqualExports = requireFastDeepEqual();
+const isEqual = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqualExports);
 const useIsomorphicLayoutEffect$1 = typeof window !== "undefined" ? useLayoutEffect : useEffect;
 function useCollector(monitor, collect, onUpdate) {
   const [collected, setCollected] = useState(
@@ -23500,6 +23413,18 @@ function toArray(arrayLike) {
   }
   return arr;
 }
+let styleProps = null;
+function getStyleProperties(options = {}) {
+  if (styleProps) {
+    return styleProps;
+  }
+  if (options.includeStyleProperties) {
+    styleProps = options.includeStyleProperties;
+    return styleProps;
+  }
+  styleProps = toArray(window.getComputedStyle(document.documentElement));
+  return styleProps;
+}
 function px(node, styleProperty) {
   const win = node.ownerDocument.defaultView || window;
   const val = win.getComputedStyle(node).getPropertyValue(styleProperty);
@@ -23601,19 +23526,19 @@ function formatCSSText(style) {
   const content = style.getPropertyValue("content");
   return `${style.cssText} content: '${content.replace(/'|"/g, "")}';`;
 }
-function formatCSSProperties(style) {
-  return toArray(style).map((name) => {
+function formatCSSProperties(style, options) {
+  return getStyleProperties(options).map((name) => {
     const value = style.getPropertyValue(name);
     const priority = style.getPropertyPriority(name);
     return `${name}: ${value}${priority ? " !important" : ""};`;
   }).join(" ");
 }
-function getPseudoElementStyle(className, pseudo, style) {
+function getPseudoElementStyle(className, pseudo, style, options) {
   const selector = `.${className}:${pseudo}`;
-  const cssText = style.cssText ? formatCSSText(style) : formatCSSProperties(style);
+  const cssText = style.cssText ? formatCSSText(style) : formatCSSProperties(style, options);
   return document.createTextNode(`${selector}{${cssText}}`);
 }
-function clonePseudoElement(nativeNode, clonedNode, pseudo) {
+function clonePseudoElement(nativeNode, clonedNode, pseudo, options) {
   const style = window.getComputedStyle(nativeNode, pseudo);
   const content = style.getPropertyValue("content");
   if (content === "" || content === "none") {
@@ -23626,12 +23551,12 @@ function clonePseudoElement(nativeNode, clonedNode, pseudo) {
     return;
   }
   const styleElement = document.createElement("style");
-  styleElement.appendChild(getPseudoElementStyle(className, pseudo, style));
+  styleElement.appendChild(getPseudoElementStyle(className, pseudo, style, options));
   clonedNode.appendChild(styleElement);
 }
-function clonePseudoElements(nativeNode, clonedNode) {
-  clonePseudoElement(nativeNode, clonedNode, ":before");
-  clonePseudoElement(nativeNode, clonedNode, ":after");
+function clonePseudoElements(nativeNode, clonedNode, options) {
+  clonePseudoElement(nativeNode, clonedNode, ":before", options);
+  clonePseudoElement(nativeNode, clonedNode, ":after", options);
 }
 const WOFF = "application/font-woff";
 const JPEG = "image/jpeg";
@@ -23747,11 +23672,11 @@ async function cloneVideoElement(video, options) {
   const dataURL = await resourceToDataURL(poster, contentType, options);
   return createImage(dataURL);
 }
-async function cloneIFrameElement(iframe) {
+async function cloneIFrameElement(iframe, options) {
   var _a2;
   try {
     if ((_a2 = iframe === null || iframe === void 0 ? void 0 : iframe.contentDocument) === null || _a2 === void 0 ? void 0 : _a2.body) {
-      return await cloneNode(iframe.contentDocument.body, {}, true);
+      return await cloneNode(iframe.contentDocument.body, options, true);
     }
   } catch (_b2) {
   }
@@ -23765,7 +23690,7 @@ async function cloneSingleNode(node, options) {
     return cloneVideoElement(node, options);
   }
   if (isInstanceOfElement(node, HTMLIFrameElement)) {
-    return cloneIFrameElement(node);
+    return cloneIFrameElement(node, options);
   }
   return node.cloneNode(isSVGElement(node));
 }
@@ -23794,7 +23719,7 @@ async function cloneChildren(nativeNode, clonedNode, options) {
   }), Promise.resolve());
   return clonedNode;
 }
-function cloneCSSStyle(nativeNode, clonedNode) {
+function cloneCSSStyle(nativeNode, clonedNode, options) {
   const targetStyle = clonedNode.style;
   if (!targetStyle) {
     return;
@@ -23804,7 +23729,7 @@ function cloneCSSStyle(nativeNode, clonedNode) {
     targetStyle.cssText = sourceStyle.cssText;
     targetStyle.transformOrigin = sourceStyle.transformOrigin;
   } else {
-    toArray(sourceStyle).forEach((name) => {
+    getStyleProperties(options).forEach((name) => {
       let value = sourceStyle.getPropertyValue(name);
       if (name === "font-size" && value.endsWith("px")) {
         const reducedFont = Math.floor(parseFloat(value.substring(0, value.length - 2))) - 0.1;
@@ -23837,10 +23762,10 @@ function cloneSelectValue(nativeNode, clonedNode) {
     }
   }
 }
-function decorate(nativeNode, clonedNode) {
+function decorate(nativeNode, clonedNode, options) {
   if (isInstanceOfElement(clonedNode, Element)) {
-    cloneCSSStyle(nativeNode, clonedNode);
-    clonePseudoElements(nativeNode, clonedNode);
+    cloneCSSStyle(nativeNode, clonedNode, options);
+    clonePseudoElements(nativeNode, clonedNode, options);
     cloneInputValue(nativeNode, clonedNode);
     cloneSelectValue(nativeNode, clonedNode);
   }
@@ -23886,7 +23811,7 @@ async function cloneNode(node, options, isRoot) {
   if (!isRoot && options.filter && !options.filter(node)) {
     return null;
   }
-  return Promise.resolve(node).then((clonedNode) => cloneSingleNode(clonedNode, options)).then((clonedNode) => cloneChildren(node, clonedNode, options)).then((clonedNode) => decorate(node, clonedNode)).then((clonedNode) => ensureSVGSymbols(clonedNode, options));
+  return Promise.resolve(node).then((clonedNode) => cloneSingleNode(clonedNode, options)).then((clonedNode) => cloneChildren(node, clonedNode, options)).then((clonedNode) => decorate(node, clonedNode, options)).then((clonedNode) => ensureSVGSymbols(clonedNode, options));
 }
 const URL_REGEX = /url\((['"]?)([^'"]+?)\1\)/g;
 const URL_WITH_FORMAT_REGEX = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g;
@@ -23952,12 +23877,8 @@ async function embedProp(propName, node, options) {
   return false;
 }
 async function embedBackground(clonedNode, options) {
-  if (!await embedProp("background", clonedNode, options)) {
-    await embedProp("background-image", clonedNode, options);
-  }
-  if (!await embedProp("mask", clonedNode, options)) {
-    await embedProp("mask-image", clonedNode, options);
-  }
+  await embedProp("background", clonedNode, options) || await embedProp("background-image", clonedNode, options);
+  await embedProp("mask", clonedNode, options) || await embedProp("-webkit-mask", clonedNode, options) || await embedProp("mask-image", clonedNode, options) || await embedProp("-webkit-mask-image", clonedNode, options);
 }
 async function embedImageNode(clonedNode, options) {
   const isImageElement = isInstanceOfElement(clonedNode, HTMLImageElement);
@@ -24113,7 +24034,7 @@ async function getCSSRules(styleSheets, options) {
         const inline = styleSheets.find((a2) => a2.href == null) || document.styleSheets[0];
         if (sheet.href != null) {
           deferreds.push(fetchCSS(sheet.href).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => {
-            inline.insertRule(rule, sheet.cssRules.length);
+            inline.insertRule(rule, inline.cssRules.length);
           })).catch((err) => {
             console.error("Error loading remote stylesheet", err);
           }));
@@ -24226,200 +24147,206 @@ async function toPng(node, options = {}) {
   return canvas2.toDataURL();
 }
 var dist = { exports: {} };
-(function(module, exports) {
-  !function(e2, t) {
-    module.exports = t(React__default);
-  }(window, function(e2) {
-    return function(e3) {
-      var t = {};
-      function n2(o2) {
-        if (t[o2]) return t[o2].exports;
-        var r2 = t[o2] = { i: o2, l: false, exports: {} };
-        return e3[o2].call(r2.exports, r2, r2.exports, n2), r2.l = true, r2.exports;
-      }
-      return n2.m = e3, n2.c = t, n2.d = function(e4, t2, o2) {
-        n2.o(e4, t2) || Object.defineProperty(e4, t2, { enumerable: true, get: o2 });
-      }, n2.r = function(e4) {
-        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e4, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e4, "__esModule", { value: true });
-      }, n2.t = function(e4, t2) {
-        if (1 & t2 && (e4 = n2(e4)), 8 & t2) return e4;
-        if (4 & t2 && "object" == typeof e4 && e4 && e4.__esModule) return e4;
-        var o2 = /* @__PURE__ */ Object.create(null);
-        if (n2.r(o2), Object.defineProperty(o2, "default", { enumerable: true, value: e4 }), 2 & t2 && "string" != typeof e4) for (var r2 in e4) n2.d(o2, r2, (function(t3) {
-          return e4[t3];
-        }).bind(null, r2));
-        return o2;
-      }, n2.n = function(e4) {
-        var t2 = e4 && e4.__esModule ? function() {
-          return e4.default;
-        } : function() {
-          return e4;
-        };
-        return n2.d(t2, "a", t2), t2;
-      }, n2.o = function(e4, t2) {
-        return Object.prototype.hasOwnProperty.call(e4, t2);
-      }, n2.p = "/dist/", n2(n2.s = 4);
-    }([function(e3, t, n2) {
-      e3.exports = n2(5)();
-    }, function(t, n2) {
-      t.exports = e2;
-    }, function(e3, t, n2) {
-      (function(n3) {
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist.exports;
+  hasRequiredDist = 1;
+  (function(module, exports) {
+    !function(e2, t) {
+      module.exports = t(React__default);
+    }(window, function(e2) {
+      return function(e3) {
+        var t = {};
+        function n2(o2) {
+          if (t[o2]) return t[o2].exports;
+          var r2 = t[o2] = { i: o2, l: false, exports: {} };
+          return e3[o2].call(r2.exports, r2, r2.exports, n2), r2.l = true, r2.exports;
+        }
+        return n2.m = e3, n2.c = t, n2.d = function(e4, t2, o2) {
+          n2.o(e4, t2) || Object.defineProperty(e4, t2, { enumerable: true, get: o2 });
+        }, n2.r = function(e4) {
+          "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e4, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e4, "__esModule", { value: true });
+        }, n2.t = function(e4, t2) {
+          if (1 & t2 && (e4 = n2(e4)), 8 & t2) return e4;
+          if (4 & t2 && "object" == typeof e4 && e4 && e4.__esModule) return e4;
+          var o2 = /* @__PURE__ */ Object.create(null);
+          if (n2.r(o2), Object.defineProperty(o2, "default", { enumerable: true, value: e4 }), 2 & t2 && "string" != typeof e4) for (var r2 in e4) n2.d(o2, r2, (function(t3) {
+            return e4[t3];
+          }).bind(null, r2));
+          return o2;
+        }, n2.n = function(e4) {
+          var t2 = e4 && e4.__esModule ? function() {
+            return e4.default;
+          } : function() {
+            return e4;
+          };
+          return n2.d(t2, "a", t2), t2;
+        }, n2.o = function(e4, t2) {
+          return Object.prototype.hasOwnProperty.call(e4, t2);
+        }, n2.p = "/dist/", n2(n2.s = 4);
+      }([function(e3, t, n2) {
+        e3.exports = n2(5)();
+      }, function(t, n2) {
+        t.exports = e2;
+      }, function(e3, t, n2) {
+        (function(n3) {
+          var o2, r2, a2;
+          r2 = [], void 0 === (a2 = "function" == typeof (o2 = function() {
+            function t2(e4, t3, n4) {
+              var o4 = new XMLHttpRequest();
+              o4.open("GET", e4), o4.responseType = "blob", o4.onload = function() {
+                c2(o4.response, t3, n4);
+              }, o4.onerror = function() {
+                console.error("could not download file");
+              }, o4.send();
+            }
+            function o3(e4) {
+              var t3 = new XMLHttpRequest();
+              t3.open("HEAD", e4, false);
+              try {
+                t3.send();
+              } catch (e5) {
+              }
+              return 200 <= t3.status && 299 >= t3.status;
+            }
+            function r3(e4) {
+              try {
+                e4.dispatchEvent(new MouseEvent("click"));
+              } catch (n4) {
+                var t3 = document.createEvent("MouseEvents");
+                t3.initMouseEvent("click", true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null), e4.dispatchEvent(t3);
+              }
+            }
+            var a3 = "object" == typeof window && window.window === window ? window : "object" == typeof self && self.self === self ? self : "object" == typeof n3 && n3.global === n3 ? n3 : void 0, i2 = a3.navigator && /Macintosh/.test(navigator.userAgent) && /AppleWebKit/.test(navigator.userAgent) && !/Safari/.test(navigator.userAgent), c2 = a3.saveAs || ("object" != typeof window || window !== a3 ? function() {
+            } : "download" in HTMLAnchorElement.prototype && !i2 ? function(e4, n4, i3) {
+              var c3 = a3.URL || a3.webkitURL, s2 = document.createElement("a");
+              n4 = n4 || e4.name || "download", s2.download = n4, s2.rel = "noopener", "string" == typeof e4 ? (s2.href = e4, s2.origin === location.origin ? r3(s2) : o3(s2.href) ? t2(e4, n4, i3) : r3(s2, s2.target = "_blank")) : (s2.href = c3.createObjectURL(e4), setTimeout(function() {
+                c3.revokeObjectURL(s2.href);
+              }, 4e4), setTimeout(function() {
+                r3(s2);
+              }, 0));
+            } : "msSaveOrOpenBlob" in navigator ? function(e4, n4, a4) {
+              if (n4 = n4 || e4.name || "download", "string" != typeof e4) navigator.msSaveOrOpenBlob(function(e5, t3) {
+                return void 0 === t3 ? t3 = { autoBom: false } : "object" != typeof t3 && (console.warn("Deprecated: Expected third argument to be a object"), t3 = { autoBom: !t3 }), t3.autoBom && /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e5.type) ? new Blob(["\uFEFF", e5], { type: e5.type }) : e5;
+              }(e4, a4), n4);
+              else if (o3(e4)) t2(e4, n4, a4);
+              else {
+                var i3 = document.createElement("a");
+                i3.href = e4, i3.target = "_blank", setTimeout(function() {
+                  r3(i3);
+                });
+              }
+            } : function(e4, n4, o4, r4) {
+              if ((r4 = r4 || open("", "_blank")) && (r4.document.title = r4.document.body.innerText = "downloading..."), "string" == typeof e4) return t2(e4, n4, o4);
+              var c3 = "application/octet-stream" === e4.type, s2 = /constructor/i.test(a3.HTMLElement) || a3.safari, u2 = /CriOS\/[\d]+/.test(navigator.userAgent);
+              if ((u2 || c3 && s2 || i2) && "undefined" != typeof FileReader) {
+                var l2 = new FileReader();
+                l2.onloadend = function() {
+                  var e5 = l2.result;
+                  e5 = u2 ? e5 : e5.replace(/^data:[^;]*;/, "data:attachment/file;"), r4 ? r4.location.href = e5 : location = e5, r4 = null;
+                }, l2.readAsDataURL(e4);
+              } else {
+                var f2 = a3.URL || a3.webkitURL, p2 = f2.createObjectURL(e4);
+                r4 ? r4.location = p2 : location.href = p2, r4 = null, setTimeout(function() {
+                  f2.revokeObjectURL(p2);
+                }, 4e4);
+              }
+            });
+            a3.saveAs = c2.saveAs = c2, e3.exports = c2;
+          }) ? o2.apply(t, r2) : o2) || (e3.exports = a2);
+        }).call(this, n2(7));
+      }, function(e3, t, n2) {
         var o2, r2, a2;
         r2 = [], void 0 === (a2 = "function" == typeof (o2 = function() {
-          function t2(e4, t3, n4) {
-            var o4 = new XMLHttpRequest();
-            o4.open("GET", e4), o4.responseType = "blob", o4.onload = function() {
-              c2(o4.response, t3, n4);
-            }, o4.onerror = function() {
-              console.error("could not download file");
-            }, o4.send();
-          }
-          function o3(e4) {
-            var t3 = new XMLHttpRequest();
-            t3.open("HEAD", e4, false);
+          return function(e4, t2, n3) {
+            t2 = t2 || "", n3 = n3 || 512;
+            for (var o3 = atob(e4), r3 = [], a3 = 0; a3 < o3.length; a3 += n3) {
+              for (var i2 = o3.slice(a3, a3 + n3), c2 = new Array(i2.length), s2 = 0; s2 < i2.length; s2++) c2[s2] = i2.charCodeAt(s2);
+              var u2 = new Uint8Array(c2);
+              r3.push(u2);
+            }
+            return new Blob(r3, { type: t2 });
+          };
+        }) ? o2.apply(t, r2) : o2) || (e3.exports = a2);
+      }, function(e3, t, n2) {
+        n2.r(t), n2.d(t, "defaultDownloadName", function() {
+          return p2;
+        }), n2.d(t, "triggerBase64Download", function() {
+          return y2;
+        }), n2.d(t, "getExtFromBase64", function() {
+          return b2;
+        });
+        var o2 = n2(1), r2 = n2.n(o2), a2 = n2(0), i2 = n2.n(a2), c2 = n2(2), s2 = n2(3);
+        function u2() {
+          return (u2 = Object.assign || function(e4) {
+            for (var t2 = 1; t2 < arguments.length; t2++) {
+              var n3 = arguments[t2];
+              for (var o3 in n3) Object.prototype.hasOwnProperty.call(n3, o3) && (e4[o3] = n3[o3]);
+            }
+            return e4;
+          }).apply(this, arguments);
+        }
+        var l2 = { png: "image/png", jpeg: "image/jpeg", jpg: "image/jpg" }, f2 = { png: "data:".concat(l2.png, ";base64"), jpeg: "data:".concat(l2.jpeg, ";base64"), jpg: "data:".concat(l2.jpg, ";base64") }, p2 = "download", d2 = function(e4) {
+          var t2 = e4.base64, n3 = e4.children, o3 = e4.downloadName, a3 = e4.onDownloadSuccess, i3 = e4.onDownloadError, c3 = e4.Tag, s3 = e4.className, l3 = e4.style, f3 = e4.extraAttributes;
+          return r2.a.createElement(c3, u2({}, f3, { onClick: function() {
             try {
-              t3.send();
+              y2(t2, o3), a3 && a3({ base64: t2 });
             } catch (e5) {
+              console.error(e5), i3 && i3(e5);
             }
-            return 200 <= t3.status && 299 >= t3.status;
-          }
-          function r3(e4) {
-            try {
-              e4.dispatchEvent(new MouseEvent("click"));
-            } catch (n4) {
-              var t3 = document.createEvent("MouseEvents");
-              t3.initMouseEvent("click", true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null), e4.dispatchEvent(t3);
+          }, className: s3, style: l3 }), n3);
+        };
+        function y2(e4) {
+          var t2 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : p2, n3 = b2(e4), o3 = f2[n3], r3 = l2[n3], a3 = e4.replace("".concat(o3, ","), ""), i3 = s2(a3, r3), u3 = new File([i3], "".concat(t2, ".").concat(n3), { type: o3 });
+          c2.saveAs(u3);
+        }
+        function b2(e4) {
+          var t2;
+          if ("string" == typeof e4 && (t2 = Object.keys(f2).find(function(t3) {
+            return 0 === e4.indexOf(f2[t3]);
+          })), t2) return t2;
+          throw new Error("props.base64 on <Base64Downloader/> has invalid or undefined extension. expected ".concat(Object.keys(l2).join(", ")));
+        }
+        d2.defaultProps = { className: "", style: {}, downloadName: p2, Tag: "button", extraAttributes: {} }, d2.propTypes = { base64: i2.a.string.isRequired, children: i2.a.oneOfType([i2.a.node, i2.a.string]).isRequired, downloadName: i2.a.string, onDownloadSuccess: i2.a.func, onDownloadError: i2.a.func, Tag: i2.a.string, className: i2.a.string, style: i2.a.object, extraAttributes: i2.a.object }, t.default = d2;
+      }, function(e3, t, n2) {
+        var o2 = n2(6);
+        function r2() {
+        }
+        function a2() {
+        }
+        a2.resetWarningCache = r2, e3.exports = function() {
+          function e4(e5, t3, n4, r3, a3, i2) {
+            if (i2 !== o2) {
+              var c2 = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");
+              throw c2.name = "Invariant Violation", c2;
             }
           }
-          var a3 = "object" == typeof window && window.window === window ? window : "object" == typeof self && self.self === self ? self : "object" == typeof n3 && n3.global === n3 ? n3 : void 0, i2 = a3.navigator && /Macintosh/.test(navigator.userAgent) && /AppleWebKit/.test(navigator.userAgent) && !/Safari/.test(navigator.userAgent), c2 = a3.saveAs || ("object" != typeof window || window !== a3 ? function() {
-          } : "download" in HTMLAnchorElement.prototype && !i2 ? function(e4, n4, i3) {
-            var c3 = a3.URL || a3.webkitURL, s2 = document.createElement("a");
-            n4 = n4 || e4.name || "download", s2.download = n4, s2.rel = "noopener", "string" == typeof e4 ? (s2.href = e4, s2.origin === location.origin ? r3(s2) : o3(s2.href) ? t2(e4, n4, i3) : r3(s2, s2.target = "_blank")) : (s2.href = c3.createObjectURL(e4), setTimeout(function() {
-              c3.revokeObjectURL(s2.href);
-            }, 4e4), setTimeout(function() {
-              r3(s2);
-            }, 0));
-          } : "msSaveOrOpenBlob" in navigator ? function(e4, n4, a4) {
-            if (n4 = n4 || e4.name || "download", "string" != typeof e4) navigator.msSaveOrOpenBlob(function(e5, t3) {
-              return void 0 === t3 ? t3 = { autoBom: false } : "object" != typeof t3 && (console.warn("Deprecated: Expected third argument to be a object"), t3 = { autoBom: !t3 }), t3.autoBom && /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e5.type) ? new Blob(["\uFEFF", e5], { type: e5.type }) : e5;
-            }(e4, a4), n4);
-            else if (o3(e4)) t2(e4, n4, a4);
-            else {
-              var i3 = document.createElement("a");
-              i3.href = e4, i3.target = "_blank", setTimeout(function() {
-                r3(i3);
-              });
-            }
-          } : function(e4, n4, o4, r4) {
-            if ((r4 = r4 || open("", "_blank")) && (r4.document.title = r4.document.body.innerText = "downloading..."), "string" == typeof e4) return t2(e4, n4, o4);
-            var c3 = "application/octet-stream" === e4.type, s2 = /constructor/i.test(a3.HTMLElement) || a3.safari, u2 = /CriOS\/[\d]+/.test(navigator.userAgent);
-            if ((u2 || c3 && s2 || i2) && "undefined" != typeof FileReader) {
-              var l2 = new FileReader();
-              l2.onloadend = function() {
-                var e5 = l2.result;
-                e5 = u2 ? e5 : e5.replace(/^data:[^;]*;/, "data:attachment/file;"), r4 ? r4.location.href = e5 : location = e5, r4 = null;
-              }, l2.readAsDataURL(e4);
-            } else {
-              var f2 = a3.URL || a3.webkitURL, p2 = f2.createObjectURL(e4);
-              r4 ? r4.location = p2 : location.href = p2, r4 = null, setTimeout(function() {
-                f2.revokeObjectURL(p2);
-              }, 4e4);
-            }
-          });
-          a3.saveAs = c2.saveAs = c2, e3.exports = c2;
-        }) ? o2.apply(t, r2) : o2) || (e3.exports = a2);
-      }).call(this, n2(7));
-    }, function(e3, t, n2) {
-      var o2, r2, a2;
-      r2 = [], void 0 === (a2 = "function" == typeof (o2 = function() {
-        return function(e4, t2, n3) {
-          t2 = t2 || "", n3 = n3 || 512;
-          for (var o3 = atob(e4), r3 = [], a3 = 0; a3 < o3.length; a3 += n3) {
-            for (var i2 = o3.slice(a3, a3 + n3), c2 = new Array(i2.length), s2 = 0; s2 < i2.length; s2++) c2[s2] = i2.charCodeAt(s2);
-            var u2 = new Uint8Array(c2);
-            r3.push(u2);
+          function t2() {
+            return e4;
           }
-          return new Blob(r3, { type: t2 });
+          e4.isRequired = e4;
+          var n3 = { array: e4, bool: e4, func: e4, number: e4, object: e4, string: e4, symbol: e4, any: e4, arrayOf: t2, element: e4, elementType: e4, instanceOf: t2, node: e4, objectOf: t2, oneOf: t2, oneOfType: t2, shape: t2, exact: t2, checkPropTypes: a2, resetWarningCache: r2 };
+          return n3.PropTypes = n3, n3;
         };
-      }) ? o2.apply(t, r2) : o2) || (e3.exports = a2);
-    }, function(e3, t, n2) {
-      n2.r(t), n2.d(t, "defaultDownloadName", function() {
-        return p2;
-      }), n2.d(t, "triggerBase64Download", function() {
-        return y2;
-      }), n2.d(t, "getExtFromBase64", function() {
-        return b2;
-      });
-      var o2 = n2(1), r2 = n2.n(o2), a2 = n2(0), i2 = n2.n(a2), c2 = n2(2), s2 = n2(3);
-      function u2() {
-        return (u2 = Object.assign || function(e4) {
-          for (var t2 = 1; t2 < arguments.length; t2++) {
-            var n3 = arguments[t2];
-            for (var o3 in n3) Object.prototype.hasOwnProperty.call(n3, o3) && (e4[o3] = n3[o3]);
-          }
-          return e4;
-        }).apply(this, arguments);
-      }
-      var l2 = { png: "image/png", jpeg: "image/jpeg", jpg: "image/jpg" }, f2 = { png: "data:".concat(l2.png, ";base64"), jpeg: "data:".concat(l2.jpeg, ";base64"), jpg: "data:".concat(l2.jpg, ";base64") }, p2 = "download", d2 = function(e4) {
-        var t2 = e4.base64, n3 = e4.children, o3 = e4.downloadName, a3 = e4.onDownloadSuccess, i3 = e4.onDownloadError, c3 = e4.Tag, s3 = e4.className, l3 = e4.style, f3 = e4.extraAttributes;
-        return r2.a.createElement(c3, u2({}, f3, { onClick: function() {
-          try {
-            y2(t2, o3), a3 && a3({ base64: t2 });
-          } catch (e5) {
-            console.error(e5), i3 && i3(e5);
-          }
-        }, className: s3, style: l3 }), n3);
-      };
-      function y2(e4) {
-        var t2 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : p2, n3 = b2(e4), o3 = f2[n3], r3 = l2[n3], a3 = e4.replace("".concat(o3, ","), ""), i3 = s2(a3, r3), u3 = new File([i3], "".concat(t2, ".").concat(n3), { type: o3 });
-        c2.saveAs(u3);
-      }
-      function b2(e4) {
-        var t2;
-        if ("string" == typeof e4 && (t2 = Object.keys(f2).find(function(t3) {
-          return 0 === e4.indexOf(f2[t3]);
-        })), t2) return t2;
-        throw new Error("props.base64 on <Base64Downloader/> has invalid or undefined extension. expected ".concat(Object.keys(l2).join(", ")));
-      }
-      d2.defaultProps = { className: "", style: {}, downloadName: p2, Tag: "button", extraAttributes: {} }, d2.propTypes = { base64: i2.a.string.isRequired, children: i2.a.oneOfType([i2.a.node, i2.a.string]).isRequired, downloadName: i2.a.string, onDownloadSuccess: i2.a.func, onDownloadError: i2.a.func, Tag: i2.a.string, className: i2.a.string, style: i2.a.object, extraAttributes: i2.a.object }, t.default = d2;
-    }, function(e3, t, n2) {
-      var o2 = n2(6);
-      function r2() {
-      }
-      function a2() {
-      }
-      a2.resetWarningCache = r2, e3.exports = function() {
-        function e4(e5, t3, n4, r3, a3, i2) {
-          if (i2 !== o2) {
-            var c2 = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");
-            throw c2.name = "Invariant Violation", c2;
-          }
-        }
-        function t2() {
-          return e4;
+      }, function(e3, t, n2) {
+        e3.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+      }, function(e3, t) {
+        var n2;
+        n2 = /* @__PURE__ */ function() {
+          return this;
+        }();
+        try {
+          n2 = n2 || new Function("return this")();
+        } catch (e4) {
+          "object" == typeof window && (n2 = window);
         }
-        e4.isRequired = e4;
-        var n3 = { array: e4, bool: e4, func: e4, number: e4, object: e4, string: e4, symbol: e4, any: e4, arrayOf: t2, element: e4, elementType: e4, instanceOf: t2, node: e4, objectOf: t2, oneOf: t2, oneOfType: t2, shape: t2, exact: t2, checkPropTypes: a2, resetWarningCache: r2 };
-        return n3.PropTypes = n3, n3;
-      };
-    }, function(e3, t, n2) {
-      e3.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
-    }, function(e3, t) {
-      var n2;
-      n2 = /* @__PURE__ */ function() {
-        return this;
-      }();
-      try {
-        n2 = n2 || new Function("return this")();
-      } catch (e4) {
-        "object" == typeof window && (n2 = window);
-      }
-      e3.exports = n2;
-    }]);
-  });
-})(dist);
-var distExports = dist.exports;
+        e3.exports = n2;
+      }]);
+    });
+  })(dist);
+  return dist.exports;
+}
+var distExports = requireDist();
 const downloadPgn = (chartRef, state) => {
   var _a2;
   const chart2 = chartRef.current;