@zyzgroup/core-web 0.1.96 → 0.1.97

package/dist/hammer-ea5fdcf5.js

@@ -0,0 +1,1205 @@
+import { g as He } from "./index-c0e1658b.js";
+function Fe(L, c) {
+  for (var b = 0; b < c.length; b++) {
+    const S = c[b];
+    if (typeof S != "string" && !Array.isArray(S)) {
+      for (const o in S)
+        if (o !== "default" && !(o in L)) {
+          const Y = Object.getOwnPropertyDescriptor(S, o);
+          Y && Object.defineProperty(L, o, Y.get ? Y : {
+            enumerable: !0,
+            get: () => S[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(L, Symbol.toStringTag, { value: "Module" }));
+}
+var Qt = { exports: {} };
+/*! Hammer.JS - v2.0.7 - 2016-04-22
+ * http://hammerjs.github.io/
+ *
+ * Copyright (c) 2016 Jorik Tangelder;
+ * Licensed under the MIT license */
+(function(L) {
+  (function(c, b, S, o) {
+    var Y = ["", "webkit", "Moz", "MS", "ms", "o"], $t = b.createElement("div"), te = "function", H = Math.round, D = Math.abs, lt = Date.now;
+    function ut(t, e, i) {
+      return setTimeout(ft(t, i), e);
+    }
+    function F(t, e, i) {
+      return Array.isArray(t) ? (P(t, i[e], i), !0) : !1;
+    }
+    function P(t, e, i) {
+      var r;
+      if (t)
+        if (t.forEach)
+          t.forEach(e, i);
+        else if (t.length !== o)
+          for (r = 0; r < t.length; )
+            e.call(i, t[r], r, t), r++;
+        else
+          for (r in t)
+            t.hasOwnProperty(r) && e.call(i, t[r], r, t);
+    }
+    function Ot(t, e, i) {
+      var r = "DEPRECATED METHOD: " + e + `
+` + i + ` AT 
+`;
+      return function() {
+        var n = new Error("get-stack-trace"), s = n && n.stack ? n.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.<anonymous>\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace", a = c.console && (c.console.warn || c.console.log);
+        return a && a.call(c.console, r, s), t.apply(this, arguments);
+      };
+    }
+    var g;
+    typeof Object.assign != "function" ? g = function(e) {
+      if (e === o || e === null)
+        throw new TypeError("Cannot convert undefined or null to object");
+      for (var i = Object(e), r = 1; r < arguments.length; r++) {
+        var n = arguments[r];
+        if (n !== o && n !== null)
+          for (var s in n)
+            n.hasOwnProperty(s) && (i[s] = n[s]);
+      }
+      return i;
+    } : g = Object.assign;
+    var At = Ot(function(e, i, r) {
+      for (var n = Object.keys(i), s = 0; s < n.length; )
+        (!r || r && e[n[s]] === o) && (e[n[s]] = i[n[s]]), s++;
+      return e;
+    }, "extend", "Use `assign`."), ee = Ot(function(e, i) {
+      return At(e, i, !0);
+    }, "merge", "Use `assign`.");
+    function T(t, e, i) {
+      var r = e.prototype, n;
+      n = t.prototype = Object.create(r), n.constructor = t, n._super = r, i && g(n, i);
+    }
+    function ft(t, e) {
+      return function() {
+        return t.apply(e, arguments);
+      };
+    }
+    function vt(t, e) {
+      return typeof t == te ? t.apply(e && e[0] || o, e) : t;
+    }
+    function Ct(t, e) {
+      return t === o ? e : t;
+    }
+    function B(t, e, i) {
+      P(Q(e), function(r) {
+        t.addEventListener(r, i, !1);
+      });
+    }
+    function J(t, e, i) {
+      P(Q(e), function(r) {
+        t.removeEventListener(r, i, !1);
+      });
+    }
+    function St(t, e) {
+      for (; t; ) {
+        if (t == e)
+          return !0;
+        t = t.parentNode;
+      }
+      return !1;
+    }
+    function M(t, e) {
+      return t.indexOf(e) > -1;
+    }
+    function Q(t) {
+      return t.trim().split(/\s+/g);
+    }
+    function X(t, e, i) {
+      if (t.indexOf && !i)
+        return t.indexOf(e);
+      for (var r = 0; r < t.length; ) {
+        if (i && t[r][i] == e || !i && t[r] === e)
+          return r;
+        r++;
+      }
+      return -1;
+    }
+    function K(t) {
+      return Array.prototype.slice.call(t, 0);
+    }
+    function Dt(t, e, i) {
+      for (var r = [], n = [], s = 0; s < t.length; ) {
+        var a = e ? t[s][e] : t[s];
+        X(n, a) < 0 && r.push(t[s]), n[s] = a, s++;
+      }
+      return i && (e ? r = r.sort(function(u, v) {
+        return u[e] > v[e];
+      }) : r = r.sort()), r;
+    }
+    function $(t, e) {
+      for (var i, r, n = e[0].toUpperCase() + e.slice(1), s = 0; s < Y.length; ) {
+        if (i = Y[s], r = i ? i + n : e, r in t)
+          return r;
+        s++;
+      }
+      return o;
+    }
+    var ie = 1;
+    function re() {
+      return ie++;
+    }
+    function Mt(t) {
+      var e = t.ownerDocument || t;
+      return e.defaultView || e.parentWindow || c;
+    }
+    var ne = /mobile|tablet|ip(ad|hone|od)|android/i, Ut = "ontouchstart" in c, se = $(c, "PointerEvent") !== o, ae = Ut && ne.test(navigator.userAgent), W = "touch", oe = "pen", pt = "mouse", he = "kinect", ce = 25, f = 1, U = 2, h = 4, p = 8, tt = 1, q = 2, w = 4, G = 8, k = 16, _ = q | w, R = G | k, Rt = _ | R, xt = ["x", "y"], et = ["clientX", "clientY"];
+    function m(t, e) {
+      var i = this;
+      this.manager = t, this.callback = e, this.element = t.element, this.target = t.options.inputTarget, this.domHandler = function(r) {
+        vt(t.options.enable, [t]) && i.handler(r);
+      }, this.init();
+    }
+    m.prototype = {
+      /**
+       * should handle the inputEvent data and trigger the callback
+       * @virtual
+       */
+      handler: function() {
+      },
+      /**
+       * bind the events
+       */
+      init: function() {
+        this.evEl && B(this.element, this.evEl, this.domHandler), this.evTarget && B(this.target, this.evTarget, this.domHandler), this.evWin && B(Mt(this.element), this.evWin, this.domHandler);
+      },
+      /**
+       * unbind the events
+       */
+      destroy: function() {
+        this.evEl && J(this.element, this.evEl, this.domHandler), this.evTarget && J(this.target, this.evTarget, this.domHandler), this.evWin && J(Mt(this.element), this.evWin, this.domHandler);
+      }
+    };
+    function le(t) {
+      var e, i = t.options.inputClass;
+      return i ? e = i : se ? e = mt : ae ? e = nt : Ut ? e = dt : e = rt, new e(t, ue);
+    }
+    function ue(t, e, i) {
+      var r = i.pointers.length, n = i.changedPointers.length, s = e & f && r - n === 0, a = e & (h | p) && r - n === 0;
+      i.isFirst = !!s, i.isFinal = !!a, s && (t.session = {}), i.eventType = e, fe(t, i), t.emit("hammer.input", i), t.recognize(i), t.session.prevInput = i;
+    }
+    function fe(t, e) {
+      var i = t.session, r = e.pointers, n = r.length;
+      i.firstInput || (i.firstInput = Lt(e)), n > 1 && !i.firstMultiple ? i.firstMultiple = Lt(e) : n === 1 && (i.firstMultiple = !1);
+      var s = i.firstInput, a = i.firstMultiple, l = a ? a.center : s.center, u = e.center = bt(r);
+      e.timeStamp = lt(), e.deltaTime = e.timeStamp - s.timeStamp, e.angle = Tt(l, u), e.distance = it(l, u), ve(i, e), e.offsetDirection = Ht(e.deltaX, e.deltaY);
+      var v = Yt(e.deltaTime, e.deltaX, e.deltaY);
+      e.overallVelocityX = v.x, e.overallVelocityY = v.y, e.overallVelocity = D(v.x) > D(v.y) ? v.x : v.y, e.scale = a ? me(a.pointers, r) : 1, e.rotation = a ? Te(a.pointers, r) : 0, e.maxPointers = i.prevInput ? e.pointers.length > i.prevInput.maxPointers ? e.pointers.length : i.prevInput.maxPointers : e.pointers.length, pe(i, e);
+      var I = t.element;
+      St(e.srcEvent.target, I) && (I = e.srcEvent.target), e.target = I;
+    }
+    function ve(t, e) {
+      var i = e.center, r = t.offsetDelta || {}, n = t.prevDelta || {}, s = t.prevInput || {};
+      (e.eventType === f || s.eventType === h) && (n = t.prevDelta = {
+        x: s.deltaX || 0,
+        y: s.deltaY || 0
+      }, r = t.offsetDelta = {
+        x: i.x,
+        y: i.y
+      }), e.deltaX = n.x + (i.x - r.x), e.deltaY = n.y + (i.y - r.y);
+    }
+    function pe(t, e) {
+      var i = t.lastInterval || e, r = e.timeStamp - i.timeStamp, n, s, a, l;
+      if (e.eventType != p && (r > ce || i.velocity === o)) {
+        var u = e.deltaX - i.deltaX, v = e.deltaY - i.deltaY, I = Yt(r, u, v);
+        s = I.x, a = I.y, n = D(I.x) > D(I.y) ? I.x : I.y, l = Ht(u, v), t.lastInterval = e;
+      } else
+        n = i.velocity, s = i.velocityX, a = i.velocityY, l = i.direction;
+      e.velocity = n, e.velocityX = s, e.velocityY = a, e.direction = l;
+    }
+    function Lt(t) {
+      for (var e = [], i = 0; i < t.pointers.length; )
+        e[i] = {
+          clientX: H(t.pointers[i].clientX),
+          clientY: H(t.pointers[i].clientY)
+        }, i++;
+      return {
+        timeStamp: lt(),
+        pointers: e,
+        center: bt(e),
+        deltaX: t.deltaX,
+        deltaY: t.deltaY
+      };
+    }
+    function bt(t) {
+      var e = t.length;
+      if (e === 1)
+        return {
+          x: H(t[0].clientX),
+          y: H(t[0].clientY)
+        };
+      for (var i = 0, r = 0, n = 0; n < e; )
+        i += t[n].clientX, r += t[n].clientY, n++;
+      return {
+        x: H(i / e),
+        y: H(r / e)
+      };
+    }
+    function Yt(t, e, i) {
+      return {
+        x: e / t || 0,
+        y: i / t || 0
+      };
+    }
+    function Ht(t, e) {
+      return t === e ? tt : D(t) >= D(e) ? t < 0 ? q : w : e < 0 ? G : k;
+    }
+    function it(t, e, i) {
+      i || (i = xt);
+      var r = e[i[0]] - t[i[0]], n = e[i[1]] - t[i[1]];
+      return Math.sqrt(r * r + n * n);
+    }
+    function Tt(t, e, i) {
+      i || (i = xt);
+      var r = e[i[0]] - t[i[0]], n = e[i[1]] - t[i[1]];
+      return Math.atan2(n, r) * 180 / Math.PI;
+    }
+    function Te(t, e) {
+      return Tt(e[1], e[0], et) + Tt(t[1], t[0], et);
+    }
+    function me(t, e) {
+      return it(e[0], e[1], et) / it(t[0], t[1], et);
+    }
+    var de = {
+      mousedown: f,
+      mousemove: U,
+      mouseup: h
+    }, Ee = "mousedown", ge = "mousemove mouseup";
+    function rt() {
+      this.evEl = Ee, this.evWin = ge, this.pressed = !1, m.apply(this, arguments);
+    }
+    T(rt, m, {
+      /**
+       * handle mouse events
+       * @param {Object} ev
+       */
+      handler: function(e) {
+        var i = de[e.type];
+        i & f && e.button === 0 && (this.pressed = !0), i & U && e.which !== 1 && (i = h), this.pressed && (i & h && (this.pressed = !1), this.callback(this.manager, i, {
+          pointers: [e],
+          changedPointers: [e],
+          pointerType: pt,
+          srcEvent: e
+        }));
+      }
+    });
+    var _e = {
+      pointerdown: f,
+      pointermove: U,
+      pointerup: h,
+      pointercancel: p,
+      pointerout: p
+    }, ye = {
+      2: W,
+      3: oe,
+      4: pt,
+      5: he
+      // see https://twitter.com/jacobrossi/status/480596438489890816
+    }, Ft = "pointerdown", Xt = "pointermove pointerup pointercancel";
+    c.MSPointerEvent && !c.PointerEvent && (Ft = "MSPointerDown", Xt = "MSPointerMove MSPointerUp MSPointerCancel");
+    function mt() {
+      this.evEl = Ft, this.evWin = Xt, m.apply(this, arguments), this.store = this.manager.session.pointerEvents = [];
+    }
+    T(mt, m, {
+      /**
+       * handle mouse events
+       * @param {Object} ev
+       */
+      handler: function(e) {
+        var i = this.store, r = !1, n = e.type.toLowerCase().replace("ms", ""), s = _e[n], a = ye[e.pointerType] || e.pointerType, l = a == W, u = X(i, e.pointerId, "pointerId");
+        s & f && (e.button === 0 || l) ? u < 0 && (i.push(e), u = i.length - 1) : s & (h | p) && (r = !0), !(u < 0) && (i[u] = e, this.callback(this.manager, s, {
+          pointers: i,
+          changedPointers: [e],
+          pointerType: a,
+          srcEvent: e
+        }), r && i.splice(u, 1));
+      }
+    });
+    var Ie = {
+      touchstart: f,
+      touchmove: U,
+      touchend: h,
+      touchcancel: p
+    }, Pe = "touchstart", Ne = "touchstart touchmove touchend touchcancel";
+    function Vt() {
+      this.evTarget = Pe, this.evWin = Ne, this.started = !1, m.apply(this, arguments);
+    }
+    T(Vt, m, {
+      handler: function(e) {
+        var i = Ie[e.type];
+        if (i === f && (this.started = !0), !!this.started) {
+          var r = Oe.call(this, e, i);
+          i & (h | p) && r[0].length - r[1].length === 0 && (this.started = !1), this.callback(this.manager, i, {
+            pointers: r[0],
+            changedPointers: r[1],
+            pointerType: W,
+            srcEvent: e
+          });
+        }
+      }
+    });
+    function Oe(t, e) {
+      var i = K(t.touches), r = K(t.changedTouches);
+      return e & (h | p) && (i = Dt(i.concat(r), "identifier", !0)), [i, r];
+    }
+    var Ae = {
+      touchstart: f,
+      touchmove: U,
+      touchend: h,
+      touchcancel: p
+    }, Ce = "touchstart touchmove touchend touchcancel";
+    function nt() {
+      this.evTarget = Ce, this.targetIds = {}, m.apply(this, arguments);
+    }
+    T(nt, m, {
+      handler: function(e) {
+        var i = Ae[e.type], r = Se.call(this, e, i);
+        r && this.callback(this.manager, i, {
+          pointers: r[0],
+          changedPointers: r[1],
+          pointerType: W,
+          srcEvent: e
+        });
+      }
+    });
+    function Se(t, e) {
+      var i = K(t.touches), r = this.targetIds;
+      if (e & (f | U) && i.length === 1)
+        return r[i[0].identifier] = !0, [i, i];
+      var n, s, a = K(t.changedTouches), l = [], u = this.target;
+      if (s = i.filter(function(v) {
+        return St(v.target, u);
+      }), e === f)
+        for (n = 0; n < s.length; )
+          r[s[n].identifier] = !0, n++;
+      for (n = 0; n < a.length; )
+        r[a[n].identifier] && l.push(a[n]), e & (h | p) && delete r[a[n].identifier], n++;
+      if (l.length)
+        return [
+          // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
+          Dt(s.concat(l), "identifier", !0),
+          l
+        ];
+    }
+    var De = 2500, Wt = 25;
+    function dt() {
+      m.apply(this, arguments);
+      var t = ft(this.handler, this);
+      this.touch = new nt(this.manager, t), this.mouse = new rt(this.manager, t), this.primaryTouch = null, this.lastTouches = [];
+    }
+    T(dt, m, {
+      /**
+       * handle mouse and touch events
+       * @param {Hammer} manager
+       * @param {String} inputEvent
+       * @param {Object} inputData
+       */
+      handler: function(e, i, r) {
+        var n = r.pointerType == W, s = r.pointerType == pt;
+        if (!(s && r.sourceCapabilities && r.sourceCapabilities.firesTouchEvents)) {
+          if (n)
+            Me.call(this, i, r);
+          else if (s && Ue.call(this, r))
+            return;
+          this.callback(e, i, r);
+        }
+      },
+      /**
+       * remove the event listeners
+       */
+      destroy: function() {
+        this.touch.destroy(), this.mouse.destroy();
+      }
+    });
+    function Me(t, e) {
+      t & f ? (this.primaryTouch = e.changedPointers[0].identifier, qt.call(this, e)) : t & (h | p) && qt.call(this, e);
+    }
+    function qt(t) {
+      var e = t.changedPointers[0];
+      if (e.identifier === this.primaryTouch) {
+        var i = { x: e.clientX, y: e.clientY };
+        this.lastTouches.push(i);
+        var r = this.lastTouches, n = function() {
+          var s = r.indexOf(i);
+          s > -1 && r.splice(s, 1);
+        };
+        setTimeout(n, De);
+      }
+    }
+    function Ue(t) {
+      for (var e = t.srcEvent.clientX, i = t.srcEvent.clientY, r = 0; r < this.lastTouches.length; r++) {
+        var n = this.lastTouches[r], s = Math.abs(e - n.x), a = Math.abs(i - n.y);
+        if (s <= Wt && a <= Wt)
+          return !0;
+      }
+      return !1;
+    }
+    var wt = $($t.style, "touchAction"), Gt = wt !== o, kt = "compute", zt = "auto", Et = "manipulation", x = "none", z = "pan-x", Z = "pan-y", st = xe();
+    function gt(t, e) {
+      this.manager = t, this.set(e);
+    }
+    gt.prototype = {
+      /**
+       * set the touchAction value on the element or enable the polyfill
+       * @param {String} value
+       */
+      set: function(t) {
+        t == kt && (t = this.compute()), Gt && this.manager.element.style && st[t] && (this.manager.element.style[wt] = t), this.actions = t.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 t = [];
+        return P(this.manager.recognizers, function(e) {
+          vt(e.options.enable, [e]) && (t = t.concat(e.getTouchAction()));
+        }), Re(t.join(" "));
+      },
+      /**
+       * this method is called on each input cycle and provides the preventing of the browser behavior
+       * @param {Object} input
+       */
+      preventDefaults: function(t) {
+        var e = t.srcEvent, i = t.offsetDirection;
+        if (this.manager.session.prevented) {
+          e.preventDefault();
+          return;
+        }
+        var r = this.actions, n = M(r, x) && !st[x], s = M(r, Z) && !st[Z], a = M(r, z) && !st[z];
+        if (n) {
+          var l = t.pointers.length === 1, u = t.distance < 2, v = t.deltaTime < 250;
+          if (l && u && v)
+            return;
+        }
+        if (!(a && s) && (n || s && i & _ || a && i & R))
+          return this.preventSrc(e);
+      },
+      /**
+       * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
+       * @param {Object} srcEvent
+       */
+      preventSrc: function(t) {
+        this.manager.session.prevented = !0, t.preventDefault();
+      }
+    };
+    function Re(t) {
+      if (M(t, x))
+        return x;
+      var e = M(t, z), i = M(t, Z);
+      return e && i ? x : e || i ? e ? z : Z : M(t, Et) ? Et : zt;
+    }
+    function xe() {
+      if (!Gt)
+        return !1;
+      var t = {}, e = c.CSS && c.CSS.supports;
+      return ["auto", "manipulation", "pan-y", "pan-x", "pan-x pan-y", "none"].forEach(function(i) {
+        t[i] = e ? c.CSS.supports("touch-action", i) : !0;
+      }), t;
+    }
+    var at = 1, d = 2, V = 4, C = 8, N = C, j = 16, y = 32;
+    function O(t) {
+      this.options = g({}, this.defaults, t || {}), this.id = re(), this.manager = null, this.options.enable = Ct(this.options.enable, !0), this.state = at, this.simultaneous = {}, this.requireFail = [];
+    }
+    O.prototype = {
+      /**
+       * @virtual
+       * @type {Object}
+       */
+      defaults: {},
+      /**
+       * set options
+       * @param {Object} options
+       * @return {Recognizer}
+       */
+      set: function(t) {
+        return g(this.options, t), this.manager && this.manager.touchAction.update(), this;
+      },
+      /**
+       * recognize simultaneous with an other recognizer.
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      recognizeWith: function(t) {
+        if (F(t, "recognizeWith", this))
+          return this;
+        var e = this.simultaneous;
+        return t = ot(t, this), e[t.id] || (e[t.id] = t, t.recognizeWith(this)), this;
+      },
+      /**
+       * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      dropRecognizeWith: function(t) {
+        return F(t, "dropRecognizeWith", this) ? this : (t = ot(t, this), delete this.simultaneous[t.id], this);
+      },
+      /**
+       * recognizer can only run when an other is failing
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      requireFailure: function(t) {
+        if (F(t, "requireFailure", this))
+          return this;
+        var e = this.requireFail;
+        return t = ot(t, this), X(e, t) === -1 && (e.push(t), t.requireFailure(this)), this;
+      },
+      /**
+       * drop the requireFailure link. it does not remove the link on the other recognizer.
+       * @param {Recognizer} otherRecognizer
+       * @returns {Recognizer} this
+       */
+      dropRequireFailure: function(t) {
+        if (F(t, "dropRequireFailure", this))
+          return this;
+        t = ot(t, this);
+        var e = X(this.requireFail, t);
+        return e > -1 && this.requireFail.splice(e, 1), 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(t) {
+        return !!this.simultaneous[t.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(t) {
+        var e = this, i = this.state;
+        function r(n) {
+          e.manager.emit(n, t);
+        }
+        i < C && r(e.options.event + Zt(i)), r(e.options.event), t.additionalEvent && r(t.additionalEvent), i >= C && r(e.options.event + Zt(i));
+      },
+      /**
+       * 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(t) {
+        if (this.canEmit())
+          return this.emit(t);
+        this.state = y;
+      },
+      /**
+       * can we emit?
+       * @returns {boolean}
+       */
+      canEmit: function() {
+        for (var t = 0; t < this.requireFail.length; ) {
+          if (!(this.requireFail[t].state & (y | at)))
+            return !1;
+          t++;
+        }
+        return !0;
+      },
+      /**
+       * update the recognizer
+       * @param {Object} inputData
+       */
+      recognize: function(t) {
+        var e = g({}, t);
+        if (!vt(this.options.enable, [this, e])) {
+          this.reset(), this.state = y;
+          return;
+        }
+        this.state & (N | j | y) && (this.state = at), this.state = this.process(e), this.state & (d | V | C | j) && this.tryEmit(e);
+      },
+      /**
+       * return the state of the recognizer
+       * the actual recognizing happens in this method
+       * @virtual
+       * @param {Object} inputData
+       * @returns {Const} STATE
+       */
+      process: function(t) {
+      },
+      // 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 Zt(t) {
+      return t & j ? "cancel" : t & C ? "end" : t & V ? "move" : t & d ? "start" : "";
+    }
+    function jt(t) {
+      return t == k ? "down" : t == G ? "up" : t == q ? "left" : t == w ? "right" : "";
+    }
+    function ot(t, e) {
+      var i = e.manager;
+      return i ? i.get(t) : t;
+    }
+    function E() {
+      O.apply(this, arguments);
+    }
+    T(E, O, {
+      /**
+       * @namespace
+       * @memberof AttrRecognizer
+       */
+      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(t) {
+        var e = this.options.pointers;
+        return e === 0 || t.pointers.length === e;
+      },
+      /**
+       * Process the input and return the state for the recognizer
+       * @memberof AttrRecognizer
+       * @param {Object} input
+       * @returns {*} State
+       */
+      process: function(t) {
+        var e = this.state, i = t.eventType, r = e & (d | V), n = this.attrTest(t);
+        return r && (i & p || !n) ? e | j : r || n ? i & h ? e | C : e & d ? e | V : d : y;
+      }
+    });
+    function ht() {
+      E.apply(this, arguments), this.pX = null, this.pY = null;
+    }
+    T(ht, E, {
+      /**
+       * @namespace
+       * @memberof PanRecognizer
+       */
+      defaults: {
+        event: "pan",
+        threshold: 10,
+        pointers: 1,
+        direction: Rt
+      },
+      getTouchAction: function() {
+        var t = this.options.direction, e = [];
+        return t & _ && e.push(Z), t & R && e.push(z), e;
+      },
+      directionTest: function(t) {
+        var e = this.options, i = !0, r = t.distance, n = t.direction, s = t.deltaX, a = t.deltaY;
+        return n & e.direction || (e.direction & _ ? (n = s === 0 ? tt : s < 0 ? q : w, i = s != this.pX, r = Math.abs(t.deltaX)) : (n = a === 0 ? tt : a < 0 ? G : k, i = a != this.pY, r = Math.abs(t.deltaY))), t.direction = n, i && r > e.threshold && n & e.direction;
+      },
+      attrTest: function(t) {
+        return E.prototype.attrTest.call(this, t) && (this.state & d || !(this.state & d) && this.directionTest(t));
+      },
+      emit: function(t) {
+        this.pX = t.deltaX, this.pY = t.deltaY;
+        var e = jt(t.direction);
+        e && (t.additionalEvent = this.options.event + e), this._super.emit.call(this, t);
+      }
+    });
+    function _t() {
+      E.apply(this, arguments);
+    }
+    T(_t, E, {
+      /**
+       * @namespace
+       * @memberof PinchRecognizer
+       */
+      defaults: {
+        event: "pinch",
+        threshold: 0,
+        pointers: 2
+      },
+      getTouchAction: function() {
+        return [x];
+      },
+      attrTest: function(t) {
+        return this._super.attrTest.call(this, t) && (Math.abs(t.scale - 1) > this.options.threshold || this.state & d);
+      },
+      emit: function(t) {
+        if (t.scale !== 1) {
+          var e = t.scale < 1 ? "in" : "out";
+          t.additionalEvent = this.options.event + e;
+        }
+        this._super.emit.call(this, t);
+      }
+    });
+    function yt() {
+      O.apply(this, arguments), this._timer = null, this._input = null;
+    }
+    T(yt, O, {
+      /**
+       * @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 [zt];
+      },
+      process: function(t) {
+        var e = this.options, i = t.pointers.length === e.pointers, r = t.distance < e.threshold, n = t.deltaTime > e.time;
+        if (this._input = t, !r || !i || t.eventType & (h | p) && !n)
+          this.reset();
+        else if (t.eventType & f)
+          this.reset(), this._timer = ut(function() {
+            this.state = N, this.tryEmit();
+          }, e.time, this);
+        else if (t.eventType & h)
+          return N;
+        return y;
+      },
+      reset: function() {
+        clearTimeout(this._timer);
+      },
+      emit: function(t) {
+        this.state === N && (t && t.eventType & h ? this.manager.emit(this.options.event + "up", t) : (this._input.timeStamp = lt(), this.manager.emit(this.options.event, this._input)));
+      }
+    });
+    function It() {
+      E.apply(this, arguments);
+    }
+    T(It, E, {
+      /**
+       * @namespace
+       * @memberof RotateRecognizer
+       */
+      defaults: {
+        event: "rotate",
+        threshold: 0,
+        pointers: 2
+      },
+      getTouchAction: function() {
+        return [x];
+      },
+      attrTest: function(t) {
+        return this._super.attrTest.call(this, t) && (Math.abs(t.rotation) > this.options.threshold || this.state & d);
+      }
+    });
+    function Pt() {
+      E.apply(this, arguments);
+    }
+    T(Pt, E, {
+      /**
+       * @namespace
+       * @memberof SwipeRecognizer
+       */
+      defaults: {
+        event: "swipe",
+        threshold: 10,
+        velocity: 0.3,
+        direction: _ | R,
+        pointers: 1
+      },
+      getTouchAction: function() {
+        return ht.prototype.getTouchAction.call(this);
+      },
+      attrTest: function(t) {
+        var e = this.options.direction, i;
+        return e & (_ | R) ? i = t.overallVelocity : e & _ ? i = t.overallVelocityX : e & R && (i = t.overallVelocityY), this._super.attrTest.call(this, t) && e & t.offsetDirection && t.distance > this.options.threshold && t.maxPointers == this.options.pointers && D(i) > this.options.velocity && t.eventType & h;
+      },
+      emit: function(t) {
+        var e = jt(t.offsetDirection);
+        e && this.manager.emit(this.options.event + e, t), this.manager.emit(this.options.event, t);
+      }
+    });
+    function ct() {
+      O.apply(this, arguments), this.pTime = !1, this.pCenter = !1, this._timer = null, this._input = null, this.count = 0;
+    }
+    T(ct, O, {
+      /**
+       * @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 [Et];
+      },
+      process: function(t) {
+        var e = this.options, i = t.pointers.length === e.pointers, r = t.distance < e.threshold, n = t.deltaTime < e.time;
+        if (this.reset(), t.eventType & f && this.count === 0)
+          return this.failTimeout();
+        if (r && n && i) {
+          if (t.eventType != h)
+            return this.failTimeout();
+          var s = this.pTime ? t.timeStamp - this.pTime < e.interval : !0, a = !this.pCenter || it(this.pCenter, t.center) < e.posThreshold;
+          this.pTime = t.timeStamp, this.pCenter = t.center, !a || !s ? this.count = 1 : this.count += 1, this._input = t;
+          var l = this.count % e.taps;
+          if (l === 0)
+            return this.hasRequireFailures() ? (this._timer = ut(function() {
+              this.state = N, this.tryEmit();
+            }, e.interval, this), d) : N;
+        }
+        return y;
+      },
+      failTimeout: function() {
+        return this._timer = ut(function() {
+          this.state = y;
+        }, this.options.interval, this), y;
+      },
+      reset: function() {
+        clearTimeout(this._timer);
+      },
+      emit: function() {
+        this.state == N && (this._input.tapCount = this.count, this.manager.emit(this.options.event, this._input));
+      }
+    });
+    function A(t, e) {
+      return e = e || {}, e.recognizers = Ct(e.recognizers, A.defaults.preset), new Nt(t, e);
+    }
+    A.VERSION = "2.0.7", A.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: !1,
+      /**
+       * 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: kt,
+      /**
+       * @type {Boolean}
+       * @default true
+       */
+      enable: !0,
+      /**
+       * 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, ...]
+        [It, { enable: !1 }],
+        [_t, { enable: !1 }, ["rotate"]],
+        [Pt, { direction: _ }],
+        [ht, { direction: _ }, ["swipe"]],
+        [ct],
+        [ct, { event: "doubletap", taps: 2 }, ["tap"]],
+        [yt]
+      ],
+      /**
+       * 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)"
+      }
+    };
+    var Le = 1, Bt = 2;
+    function Nt(t, e) {
+      this.options = g({}, A.defaults, e || {}), this.options.inputTarget = this.options.inputTarget || t, this.handlers = {}, this.session = {}, this.recognizers = [], this.oldCssProps = {}, this.element = t, this.input = le(this), this.touchAction = new gt(this, this.options.touchAction), Jt(this, !0), P(this.options.recognizers, function(i) {
+        var r = this.add(new i[0](i[1]));
+        i[2] && r.recognizeWith(i[2]), i[3] && r.requireFailure(i[3]);
+      }, this);
+    }
+    Nt.prototype = {
+      /**
+       * set options
+       * @param {Object} options
+       * @returns {Manager}
+       */
+      set: function(t) {
+        return g(this.options, t), t.touchAction && this.touchAction.update(), t.inputTarget && (this.input.destroy(), this.input.target = t.inputTarget, this.input.init()), 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(t) {
+        this.session.stopped = t ? Bt : Le;
+      },
+      /**
+       * 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(t) {
+        var e = this.session;
+        if (!e.stopped) {
+          this.touchAction.preventDefaults(t);
+          var i, r = this.recognizers, n = e.curRecognizer;
+          (!n || n && n.state & N) && (n = e.curRecognizer = null);
+          for (var s = 0; s < r.length; )
+            i = r[s], e.stopped !== Bt && // 1
+            (!n || i == n || // 2
+            i.canRecognizeWith(n)) ? i.recognize(t) : i.reset(), !n && i.state & (d | V | C) && (n = e.curRecognizer = i), s++;
+        }
+      },
+      /**
+       * get a recognizer by its event name.
+       * @param {Recognizer|String} recognizer
+       * @returns {Recognizer|Null}
+       */
+      get: function(t) {
+        if (t instanceof O)
+          return t;
+        for (var e = this.recognizers, i = 0; i < e.length; i++)
+          if (e[i].options.event == t)
+            return e[i];
+        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(t) {
+        if (F(t, "add", this))
+          return this;
+        var e = this.get(t.options.event);
+        return e && this.remove(e), this.recognizers.push(t), t.manager = this, this.touchAction.update(), t;
+      },
+      /**
+       * remove a recognizer by name or instance
+       * @param {Recognizer|String} recognizer
+       * @returns {Manager}
+       */
+      remove: function(t) {
+        if (F(t, "remove", this))
+          return this;
+        if (t = this.get(t), t) {
+          var e = this.recognizers, i = X(e, t);
+          i !== -1 && (e.splice(i, 1), this.touchAction.update());
+        }
+        return this;
+      },
+      /**
+       * bind event
+       * @param {String} events
+       * @param {Function} handler
+       * @returns {EventEmitter} this
+       */
+      on: function(t, e) {
+        if (t !== o && e !== o) {
+          var i = this.handlers;
+          return P(Q(t), function(r) {
+            i[r] = i[r] || [], i[r].push(e);
+          }), this;
+        }
+      },
+      /**
+       * unbind event, leave emit blank to remove all handlers
+       * @param {String} events
+       * @param {Function} [handler]
+       * @returns {EventEmitter} this
+       */
+      off: function(t, e) {
+        if (t !== o) {
+          var i = this.handlers;
+          return P(Q(t), function(r) {
+            e ? i[r] && i[r].splice(X(i[r], e), 1) : delete i[r];
+          }), this;
+        }
+      },
+      /**
+       * emit event to the listeners
+       * @param {String} event
+       * @param {Object} data
+       */
+      emit: function(t, e) {
+        this.options.domEvents && be(t, e);
+        var i = this.handlers[t] && this.handlers[t].slice();
+        if (!(!i || !i.length)) {
+          e.type = t, e.preventDefault = function() {
+            e.srcEvent.preventDefault();
+          };
+          for (var r = 0; r < i.length; )
+            i[r](e), r++;
+        }
+      },
+      /**
+       * destroy the manager and unbinds all events
+       * it doesn't unbind dom events, that is the user own responsibility
+       */
+      destroy: function() {
+        this.element && Jt(this, !1), this.handlers = {}, this.session = {}, this.input.destroy(), this.element = null;
+      }
+    };
+    function Jt(t, e) {
+      var i = t.element;
+      if (i.style) {
+        var r;
+        P(t.options.cssProps, function(n, s) {
+          r = $(i.style, s), e ? (t.oldCssProps[r] = i.style[r], i.style[r] = n) : i.style[r] = t.oldCssProps[r] || "";
+        }), e || (t.oldCssProps = {});
+      }
+    }
+    function be(t, e) {
+      var i = b.createEvent("Event");
+      i.initEvent(t, !0, !0), i.gesture = e, e.target.dispatchEvent(i);
+    }
+    g(A, {
+      INPUT_START: f,
+      INPUT_MOVE: U,
+      INPUT_END: h,
+      INPUT_CANCEL: p,
+      STATE_POSSIBLE: at,
+      STATE_BEGAN: d,
+      STATE_CHANGED: V,
+      STATE_ENDED: C,
+      STATE_RECOGNIZED: N,
+      STATE_CANCELLED: j,
+      STATE_FAILED: y,
+      DIRECTION_NONE: tt,
+      DIRECTION_LEFT: q,
+      DIRECTION_RIGHT: w,
+      DIRECTION_UP: G,
+      DIRECTION_DOWN: k,
+      DIRECTION_HORIZONTAL: _,
+      DIRECTION_VERTICAL: R,
+      DIRECTION_ALL: Rt,
+      Manager: Nt,
+      Input: m,
+      TouchAction: gt,
+      TouchInput: nt,
+      MouseInput: rt,
+      PointerEventInput: mt,
+      TouchMouseInput: dt,
+      SingleTouchInput: Vt,
+      Recognizer: O,
+      AttrRecognizer: E,
+      Tap: ct,
+      Pan: ht,
+      Swipe: Pt,
+      Pinch: _t,
+      Rotate: It,
+      Press: yt,
+      on: B,
+      off: J,
+      each: P,
+      merge: ee,
+      extend: At,
+      assign: g,
+      inherit: T,
+      bindFn: ft,
+      prefixed: $
+    });
+    var Ye = typeof c < "u" ? c : typeof self < "u" ? self : {};
+    Ye.Hammer = A, typeof o == "function" && o.amd ? o(function() {
+      return A;
+    }) : L.exports ? L.exports = A : c[S] = A;
+  })(window, document, "Hammer");
+})(Qt);
+var Kt = Qt.exports;
+const Xe = /* @__PURE__ */ He(Kt), We = /* @__PURE__ */ Fe({
+  __proto__: null,
+  default: Xe
+}, [Kt]);
+export {
+  We as h
+};
+//# sourceMappingURL=hammer-ea5fdcf5.js.map