@component-hook/picker 0.1.0

package/dist/picker.es.js

@@ -0,0 +1,1874 @@
+import "./index.css";
+import { ref as L, computed as C, watch as bt, nextTick as ne, defineComponent as se, openBlock as z, createElementBlock as K, Fragment as ct, createVNode as Pt, Transition as Et, withCtx as Ct, withDirectives as Dt, createElementVNode as P, unref as A, vShow as Bt, normalizeClass as ht, normalizeStyle as ut, toDisplayString as U, renderList as xt, pushScopeId as ae, popScopeId as le } from "vue";
+/*!
+ * better-scroll / core
+ * (c) 2016-2023 ustbhuangyi
+ * Released under the MIT License.
+ */
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var mt = function(o, t) {
+  return mt = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, r) {
+    e.__proto__ = r;
+  } || function(e, r) {
+    for (var i in r) Object.prototype.hasOwnProperty.call(r, i) && (e[i] = r[i]);
+  }, mt(o, t);
+};
+function it(o, t) {
+  mt(o, t);
+  function e() {
+    this.constructor = o;
+  }
+  o.prototype = t === null ? Object.create(t) : (e.prototype = t.prototype, new e());
+}
+var N = function() {
+  return N = Object.assign || function(t) {
+    for (var e, r = 1, i = arguments.length; r < i; r++) {
+      e = arguments[r];
+      for (var n in e) Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
+    }
+    return t;
+  }, N.apply(this, arguments);
+};
+function Nt() {
+  for (var o = 0, t = 0, e = arguments.length; t < e; t++) o += arguments[t].length;
+  for (var r = Array(o), i = 0, t = 0; t < e; t++)
+    for (var n = arguments[t], s = 0, l = n.length; s < l; s++, i++)
+      r[i] = n[s];
+  return r;
+}
+var ce = [
+  {
+    sourceKey: "scroller.scrollBehaviorX.currentPos",
+    key: "x"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.currentPos",
+    key: "y"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorX.hasScroll",
+    key: "hasHorizontalScroll"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.hasScroll",
+    key: "hasVerticalScroll"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorX.contentSize",
+    key: "scrollerWidth"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.contentSize",
+    key: "scrollerHeight"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorX.maxScrollPos",
+    key: "maxScrollX"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.maxScrollPos",
+    key: "maxScrollY"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorX.minScrollPos",
+    key: "minScrollX"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.minScrollPos",
+    key: "minScrollY"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorX.movingDirection",
+    key: "movingDirectionX"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.movingDirection",
+    key: "movingDirectionY"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorX.direction",
+    key: "directionX"
+  },
+  {
+    sourceKey: "scroller.scrollBehaviorY.direction",
+    key: "directionY"
+  },
+  {
+    sourceKey: "scroller.actions.enabled",
+    key: "enabled"
+  },
+  {
+    sourceKey: "scroller.animater.pending",
+    key: "pending"
+  },
+  {
+    sourceKey: "scroller.animater.stop",
+    key: "stop"
+  },
+  {
+    sourceKey: "scroller.scrollTo",
+    key: "scrollTo"
+  },
+  {
+    sourceKey: "scroller.scrollBy",
+    key: "scrollBy"
+  },
+  {
+    sourceKey: "scroller.scrollToElement",
+    key: "scrollToElement"
+  },
+  {
+    sourceKey: "scroller.resetPosition",
+    key: "resetPosition"
+  }
+];
+function tt(o) {
+  console.error("[BScroll warn]: " + o);
+}
+var D = typeof window < "u", W = D && navigator.userAgent.toLowerCase(), he = !!(W && /wechatdevtools/.test(W)), ue = W && W.indexOf("android") > 0, pe = function() {
+  if (typeof W == "string") {
+    var o = /os (\d\d?_\d(_\d)?)/, t = o.exec(W);
+    if (!t)
+      return !1;
+    var e = t[1].split("_").map(function(r) {
+      return parseInt(r, 10);
+    });
+    return e[0] === 13 && e[1] >= 4;
+  }
+  return !1;
+}(), Rt = !1;
+if (D) {
+  var fe = "test-passive";
+  try {
+    var At = {};
+    Object.defineProperty(At, "passive", {
+      get: function() {
+        Rt = !0;
+      }
+    }), window.addEventListener(fe, function() {
+    }, At);
+  } catch {
+  }
+}
+function O() {
+  return window.performance && window.performance.now && window.performance.timing ? window.performance.now() + window.performance.timing.navigationStart : +/* @__PURE__ */ new Date();
+}
+var yt = function(o, t) {
+  for (var e in t)
+    o[e] = t[e];
+  return o;
+};
+function gt(o) {
+  return o == null;
+}
+function Mt(o, t, e) {
+  return o < t ? t : o > e ? e : o;
+}
+var Tt = D && document.createElement("div").style, H = function() {
+  if (!D)
+    return !1;
+  for (var o = [
+    {
+      key: "standard",
+      value: "transform"
+    },
+    {
+      key: "webkit",
+      value: "webkitTransform"
+    },
+    {
+      key: "Moz",
+      value: "MozTransform"
+    },
+    {
+      key: "O",
+      value: "OTransform"
+    },
+    {
+      key: "ms",
+      value: "msTransform"
+    }
+  ], t = 0, e = o; t < e.length; t++) {
+    var r = e[t];
+    if (Tt[r.value] !== void 0)
+      return r.key;
+  }
+  return !1;
+}();
+function B(o) {
+  return H === !1 ? o : H === "standard" ? o === "transitionEnd" ? "transitionend" : o : H + o.charAt(0).toUpperCase() + o.substr(1);
+}
+function Vt(o) {
+  return typeof o == "string" ? document.querySelector(o) : o;
+}
+function ve(o, t, e, r) {
+  var i = Rt ? {
+    passive: !1,
+    capture: !!r
+  } : !!r;
+  o.addEventListener(t, e, i);
+}
+function de(o, t, e, r) {
+  o.removeEventListener(t, e, {
+    capture: !!r
+  });
+}
+function $t(o) {
+  o.cancelable && o.preventDefault();
+}
+function Yt(o) {
+  for (var t = 0, e = 0; o; )
+    t -= o.offsetLeft, e -= o.offsetTop, o = o.offsetParent;
+  return {
+    left: t,
+    top: e
+  };
+}
+H && H !== "standard" && "" + H.toLowerCase();
+var me = B("transform"), jt = B("transition"), ye = D && B("perspective") in Tt, Xt = D && ("ontouchstart" in window || he), ge = D && jt in Tt, _ = {
+  transform: me,
+  transition: jt,
+  transitionTimingFunction: B("transitionTimingFunction"),
+  transitionDuration: B("transitionDuration"),
+  transitionDelay: B("transitionDelay"),
+  transformOrigin: B("transformOrigin"),
+  transitionEnd: B("transitionEnd"),
+  transitionProperty: B("transitionProperty")
+}, pt = {
+  touchstart: 1,
+  touchmove: 1,
+  touchend: 1,
+  touchcancel: 1,
+  mousedown: 2,
+  mousemove: 2,
+  mouseup: 2
+};
+function _t(o) {
+  if (o instanceof window.SVGElement) {
+    var t = o.getBoundingClientRect();
+    return {
+      top: t.top,
+      left: t.left,
+      width: t.width,
+      height: t.height
+    };
+  } else
+    return {
+      top: o.offsetTop,
+      left: o.offsetLeft,
+      width: o.offsetWidth,
+      height: o.offsetHeight
+    };
+}
+function R(o, t) {
+  for (var e in t)
+    if (t[e].test(o[e]))
+      return !0;
+  return !1;
+}
+var ke = R;
+function Te(o, t) {
+  var e = document.createEvent("Event");
+  e.initEvent(t, !0, !0), e.pageX = o.pageX, e.pageY = o.pageY, o.target.dispatchEvent(e);
+}
+function Ut(o, t) {
+  t === void 0 && (t = "click");
+  var e;
+  o.type === "mouseup" ? e = o : (o.type === "touchend" || o.type === "touchcancel") && (e = o.changedTouches[0]);
+  var r = {};
+  e && (r.screenX = e.screenX || 0, r.screenY = e.screenY || 0, r.clientX = e.clientX || 0, r.clientY = e.clientY || 0);
+  var i, n = !0, s = !0, l = o.ctrlKey, c = o.shiftKey, a = o.altKey, h = o.metaKey, u = {
+    ctrlKey: l,
+    shiftKey: c,
+    altKey: a,
+    metaKey: h
+  };
+  if (typeof MouseEvent < "u")
+    try {
+      i = new MouseEvent(t, yt(N({
+        bubbles: n,
+        cancelable: s
+      }, u), r));
+    } catch {
+      f();
+    }
+  else
+    f();
+  function f() {
+    i = document.createEvent("Event"), i.initEvent(t, n, s), yt(i, r);
+  }
+  i.forwardedTouchEvent = !0, i._constructed = !0, o.target.dispatchEvent(i);
+}
+function Se(o) {
+  Ut(o, "dblclick");
+}
+var X = {
+  // easeOutQuint
+  swipe: {
+    style: "cubic-bezier(0.23, 1, 0.32, 1)",
+    fn: function(o) {
+      return 1 + --o * o * o * o * o;
+    }
+  },
+  // easeOutQuard
+  swipeBounce: {
+    style: "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
+    fn: function(o) {
+      return o * (2 - o);
+    }
+  },
+  // easeOutQuart
+  bounce: {
+    style: "cubic-bezier(0.165, 0.84, 0.44, 1)",
+    fn: function(o) {
+      return 1 - --o * o * o * o;
+    }
+  }
+}, we = 1e3 / 60, M = D && window;
+function qt() {
+}
+var Gt = function() {
+  return D ? M.requestAnimationFrame || M.webkitRequestAnimationFrame || M.mozRequestAnimationFrame || M.oRequestAnimationFrame || // if all else fails, use setTimeout
+  function(o) {
+    return window.setTimeout(o, o.interval || we);
+  } : qt;
+}(), I = function() {
+  return D ? M.cancelAnimationFrame || M.webkitCancelAnimationFrame || M.mozCancelAnimationFrame || M.oCancelAnimationFrame || function(o) {
+    window.clearTimeout(o);
+  } : qt;
+}(), Ot = function(o) {
+}, ft = {
+  enumerable: !0,
+  configurable: !0,
+  get: Ot,
+  set: Ot
+}, be = function(o, t) {
+  for (var e = t.split("."), r = 0; r < e.length - 1; r++)
+    if (o = o[e[r]], typeof o != "object" || !o)
+      return;
+  var i = e.pop();
+  return typeof o[i] == "function" ? function() {
+    return o[i].apply(o, arguments);
+  } : o[i];
+}, Pe = function(o, t, e) {
+  for (var r = t.split("."), i, n = 0; n < r.length - 1; n++)
+    i = r[n], o[i] || (o[i] = {}), o = o[i];
+  o[r.pop()] = e;
+};
+function Ee(o, t, e) {
+  ft.get = function() {
+    return be(this, t);
+  }, ft.set = function(i) {
+    Pe(this, t, i);
+  }, Object.defineProperty(o, e, ft);
+}
+var Y = (
+  /** @class */
+  function() {
+    function o(t) {
+      this.events = {}, this.eventTypes = {}, this.registerType(t);
+    }
+    return o.prototype.on = function(t, e, r) {
+      return r === void 0 && (r = this), this.hasType(t), this.events[t] || (this.events[t] = []), this.events[t].push([e, r]), this;
+    }, o.prototype.once = function(t, e, r) {
+      var i = this;
+      r === void 0 && (r = this), this.hasType(t);
+      var n = function() {
+        for (var s = [], l = 0; l < arguments.length; l++)
+          s[l] = arguments[l];
+        i.off(t, n);
+        var c = e.apply(r, s);
+        if (c === !0)
+          return c;
+      };
+      return n.fn = e, this.on(t, n), this;
+    }, o.prototype.off = function(t, e) {
+      if (!t && !e)
+        return this.events = {}, this;
+      if (t) {
+        if (this.hasType(t), !e)
+          return this.events[t] = [], this;
+        var r = this.events[t];
+        if (!r)
+          return this;
+        for (var i = r.length; i--; )
+          (r[i][0] === e || r[i][0] && r[i][0].fn === e) && r.splice(i, 1);
+        return this;
+      }
+    }, o.prototype.trigger = function(t) {
+      for (var e = [], r = 1; r < arguments.length; r++)
+        e[r - 1] = arguments[r];
+      this.hasType(t);
+      var i = this.events[t];
+      if (i)
+        for (var n = i.length, s = Nt(i), l, c = 0; c < n; c++) {
+          var a = s[c], h = a[0], u = a[1];
+          if (h && (l = h.apply(u, e), l === !0))
+            return l;
+        }
+    }, o.prototype.registerType = function(t) {
+      var e = this;
+      t.forEach(function(r) {
+        e.eventTypes[r] = r;
+      });
+    }, o.prototype.destroy = function() {
+      this.events = {}, this.eventTypes = {};
+    }, o.prototype.hasType = function(t) {
+      var e = this.eventTypes, r = e[t] === t;
+      r || tt('EventEmitter has used unknown event type: "' + t + '", should be oneof [' + ("" + Object.keys(e).map(function(i) {
+        return JSON.stringify(i);
+      })) + "]");
+    }, o;
+  }()
+), et = (
+  /** @class */
+  function() {
+    function o(t, e) {
+      this.wrapper = t, this.events = e, this.addDOMEvents();
+    }
+    return o.prototype.destroy = function() {
+      this.removeDOMEvents(), this.events = [];
+    }, o.prototype.addDOMEvents = function() {
+      this.handleDOMEvents(ve);
+    }, o.prototype.removeDOMEvents = function() {
+      this.handleDOMEvents(de);
+    }, o.prototype.handleDOMEvents = function(t) {
+      var e = this, r = this.wrapper;
+      this.events.forEach(function(i) {
+        t(r, i.name, e, !!i.capture);
+      });
+    }, o.prototype.handleEvent = function(t) {
+      var e = t.type;
+      this.events.some(function(r) {
+        return r.name === e ? (r.handler(t), !0) : !1;
+      });
+    }, o;
+  }()
+), Ce = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function o() {
+    }
+    return o;
+  }()
+), De = (
+  /** @class */
+  function(o) {
+    it(t, o);
+    function t() {
+      var e = o.call(this) || this;
+      return e.startX = 0, e.startY = 0, e.scrollX = !1, e.scrollY = !0, e.freeScroll = !1, e.directionLockThreshold = 0, e.eventPassthrough = "", e.click = !1, e.dblclick = !1, e.tap = "", e.bounce = {
+        top: !0,
+        bottom: !0,
+        left: !0,
+        right: !0
+      }, e.bounceTime = 800, e.momentum = !0, e.momentumLimitTime = 300, e.momentumLimitDistance = 15, e.swipeTime = 2500, e.swipeBounceTime = 500, e.deceleration = 15e-4, e.flickLimitTime = 200, e.flickLimitDistance = 100, e.resizePolling = 60, e.probeType = 0, e.stopPropagation = !1, e.preventDefault = !0, e.preventDefaultException = {
+        tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|AUDIO)$/
+      }, e.tagException = {
+        tagName: /^TEXTAREA$/
+      }, e.HWCompositing = !0, e.useTransition = !0, e.bindToWrapper = !1, e.bindToTarget = !1, e.disableMouse = Xt, e.disableTouch = !Xt, e.autoBlur = !0, e.autoEndDistance = 5, e.outOfBoundaryDampingFactor = 1 / 3, e.specifiedIndexAsContent = 0, e.quadrant = 1, e;
+    }
+    return t.prototype.merge = function(e) {
+      if (!e)
+        return this;
+      for (var r in e) {
+        if (r === "bounce") {
+          this.bounce = this.resolveBounce(e[r]);
+          continue;
+        }
+        this[r] = e[r];
+      }
+      return this;
+    }, t.prototype.process = function() {
+      return this.translateZ = this.HWCompositing && ye ? " translateZ(1px)" : "", this.useTransition = this.useTransition && ge, this.preventDefault = !this.eventPassthrough && this.preventDefault, this.scrollX = this.eventPassthrough === "horizontal" ? !1 : this.scrollX, this.scrollY = this.eventPassthrough === "vertical" ? !1 : this.scrollY, this.freeScroll = this.freeScroll && !this.eventPassthrough, this.scrollX = this.freeScroll ? !0 : this.scrollX, this.scrollY = this.freeScroll ? !0 : this.scrollY, this.directionLockThreshold = this.eventPassthrough ? 0 : this.directionLockThreshold, this;
+    }, t.prototype.resolveBounce = function(e) {
+      var r = {
+        top: !0,
+        right: !0,
+        bottom: !0,
+        left: !0
+      }, i = {
+        top: !1,
+        right: !1,
+        bottom: !1,
+        left: !1
+      }, n;
+      return typeof e == "object" ? n = yt(r, e) : n = e ? r : i, n;
+    }, t;
+  }(Ce)
+), Be = (
+  /** @class */
+  function() {
+    function o(t, e) {
+      this.wrapper = t, this.options = e, this.hooks = new Y([
+        "beforeStart",
+        "start",
+        "move",
+        "end",
+        "click"
+      ]), this.handleDOMEvents();
+    }
+    return o.prototype.handleDOMEvents = function() {
+      var t = this.options, e = t.bindToWrapper, r = t.disableMouse, i = t.disableTouch, n = t.click, s = this.wrapper, l = e ? s : window, c = [], a = [], h = !i, u = !r;
+      n && c.push({
+        name: "click",
+        handler: this.click.bind(this),
+        capture: !0
+      }), h && (c.push({
+        name: "touchstart",
+        handler: this.start.bind(this)
+      }), a.push({
+        name: "touchmove",
+        handler: this.move.bind(this)
+      }, {
+        name: "touchend",
+        handler: this.end.bind(this)
+      }, {
+        name: "touchcancel",
+        handler: this.end.bind(this)
+      })), u && (c.push({
+        name: "mousedown",
+        handler: this.start.bind(this)
+      }), a.push({
+        name: "mousemove",
+        handler: this.move.bind(this)
+      }, {
+        name: "mouseup",
+        handler: this.end.bind(this)
+      })), this.wrapperEventRegister = new et(s, c), this.targetEventRegister = new et(l, a);
+    }, o.prototype.beforeHandler = function(t, e) {
+      var r = this.options, i = r.preventDefault, n = r.stopPropagation, s = r.preventDefaultException, l = {
+        start: function() {
+          return i && !R(t.target, s);
+        },
+        end: function() {
+          return i && !R(t.target, s);
+        },
+        move: function() {
+          return i;
+        }
+      };
+      l[e]() && t.preventDefault(), n && t.stopPropagation();
+    }, o.prototype.setInitiated = function(t) {
+      t === void 0 && (t = 0), this.initiated = t;
+    }, o.prototype.start = function(t) {
+      var e = pt[t.type];
+      if (!(this.initiated && this.initiated !== e)) {
+        if (this.setInitiated(e), ke(t.target, this.options.tagException)) {
+          this.setInitiated();
+          return;
+        }
+        if (!(e === 2 && t.button !== 0) && !this.hooks.trigger(this.hooks.eventTypes.beforeStart, t)) {
+          this.beforeHandler(t, "start");
+          var r = t.touches ? t.touches[0] : t;
+          this.pointX = r.pageX, this.pointY = r.pageY, this.hooks.trigger(this.hooks.eventTypes.start, t);
+        }
+      }
+    }, o.prototype.move = function(t) {
+      if (pt[t.type] === this.initiated) {
+        this.beforeHandler(t, "move");
+        var e = t.touches ? t.touches[0] : t, r = e.pageX - this.pointX, i = e.pageY - this.pointY;
+        if (this.pointX = e.pageX, this.pointY = e.pageY, !this.hooks.trigger(this.hooks.eventTypes.move, {
+          deltaX: r,
+          deltaY: i,
+          e: t
+        })) {
+          var n = document.documentElement.scrollLeft || window.pageXOffset || document.body.scrollLeft, s = document.documentElement.scrollTop || window.pageYOffset || document.body.scrollTop, l = this.pointX - n, c = this.pointY - s, a = this.options.autoEndDistance;
+          (l > document.documentElement.clientWidth - a || c > document.documentElement.clientHeight - a || l < a || c < a) && this.end(t);
+        }
+      }
+    }, o.prototype.end = function(t) {
+      pt[t.type] === this.initiated && (this.setInitiated(), this.beforeHandler(t, "end"), this.hooks.trigger(this.hooks.eventTypes.end, t));
+    }, o.prototype.click = function(t) {
+      this.hooks.trigger(this.hooks.eventTypes.click, t);
+    }, o.prototype.setContent = function(t) {
+      t !== this.wrapper && (this.wrapper = t, this.rebindDOMEvents());
+    }, o.prototype.rebindDOMEvents = function() {
+      this.wrapperEventRegister.destroy(), this.targetEventRegister.destroy(), this.handleDOMEvents();
+    }, o.prototype.destroy = function() {
+      this.wrapperEventRegister.destroy(), this.targetEventRegister.destroy(), this.hooks.destroy();
+    }, o;
+  }()
+), vt = {
+  x: ["translateX", "px"],
+  y: ["translateY", "px"]
+}, xe = (
+  /** @class */
+  function() {
+    function o(t) {
+      this.setContent(t), this.hooks = new Y(["beforeTranslate", "translate"]);
+    }
+    return o.prototype.getComputedPosition = function() {
+      var t = window.getComputedStyle(this.content, null), e = t[_.transform].split(")")[0].split(", "), r = +(e[12] || e[4]) || 0, i = +(e[13] || e[5]) || 0;
+      return {
+        x: r,
+        y: i
+      };
+    }, o.prototype.translate = function(t) {
+      var e = [];
+      Object.keys(t).forEach(function(r) {
+        if (vt[r]) {
+          var i = vt[r][0];
+          if (i) {
+            var n = vt[r][1], s = t[r];
+            e.push(i + "(" + s + n + ")");
+          }
+        }
+      }), this.hooks.trigger(this.hooks.eventTypes.beforeTranslate, e, t), this.style[_.transform] = e.join(" "), this.hooks.trigger(this.hooks.eventTypes.translate, t);
+    }, o.prototype.setContent = function(t) {
+      this.content !== t && (this.content = t, this.style = t.style);
+    }, o.prototype.destroy = function() {
+      this.hooks.destroy();
+    }, o;
+  }()
+), Zt = (
+  /** @class */
+  function() {
+    function o(t, e, r) {
+      this.translater = e, this.options = r, this.timer = 0, this.hooks = new Y([
+        "move",
+        "end",
+        "beforeForceStop",
+        "forceStop",
+        "callStop",
+        "time",
+        "timeFunction"
+      ]), this.setContent(t);
+    }
+    return o.prototype.translate = function(t) {
+      this.translater.translate(t);
+    }, o.prototype.setPending = function(t) {
+      this.pending = t;
+    }, o.prototype.setForceStopped = function(t) {
+      this.forceStopped = t;
+    }, o.prototype.setCallStop = function(t) {
+      this.callStopWhenPending = t;
+    }, o.prototype.setContent = function(t) {
+      this.content !== t && (this.content = t, this.style = t.style, this.stop());
+    }, o.prototype.clearTimer = function() {
+      this.timer && (I(this.timer), this.timer = 0);
+    }, o.prototype.destroy = function() {
+      this.hooks.destroy(), I(this.timer);
+    }, o;
+  }()
+), Ae = function(o, t, e, r) {
+  var i = function(a, h) {
+    var u = a - h, f = u > 0 ? -1 : u < 0 ? 1 : 0;
+    return f;
+  }, n = i(t.x, o.x), s = i(t.y, o.y), l = e.x - r.x, c = e.y - r.y;
+  return n * l <= 0 && s * c <= 0;
+}, Me = (
+  /** @class */
+  function(o) {
+    it(t, o);
+    function t() {
+      return o !== null && o.apply(this, arguments) || this;
+    }
+    return t.prototype.startProbe = function(e, r) {
+      var i = this, n = e, s = function() {
+        var l = i.translater.getComputedPosition();
+        Ae(e, r, l, n) && i.hooks.trigger(i.hooks.eventTypes.move, l), i.pending || (i.callStopWhenPending ? i.callStopWhenPending = !1 : i.hooks.trigger(i.hooks.eventTypes.end, l)), n = l, i.pending && (i.timer = Gt(s));
+      };
+      this.callStopWhenPending && this.setCallStop(!1), I(this.timer), s();
+    }, t.prototype.transitionTime = function(e) {
+      e === void 0 && (e = 0), this.style[_.transitionDuration] = e + "ms", this.hooks.trigger(this.hooks.eventTypes.time, e);
+    }, t.prototype.transitionTimingFunction = function(e) {
+      this.style[_.transitionTimingFunction] = e, this.hooks.trigger(this.hooks.eventTypes.timeFunction, e);
+    }, t.prototype.transitionProperty = function() {
+      this.style[_.transitionProperty] = _.transform;
+    }, t.prototype.move = function(e, r, i, n) {
+      this.setPending(i > 0), this.transitionTimingFunction(n), this.transitionProperty(), this.transitionTime(i), this.translate(r);
+      var s = this.options.probeType === 3;
+      i && s && this.startProbe(e, r), i || (this._reflow = this.content.offsetHeight, s && this.hooks.trigger(this.hooks.eventTypes.move, r), this.hooks.trigger(this.hooks.eventTypes.end, r));
+    }, t.prototype.doStop = function() {
+      var e = this.pending;
+      if (this.setForceStopped(!1), this.setCallStop(!1), e) {
+        this.setPending(!1), I(this.timer);
+        var r = this.translater.getComputedPosition(), i = r.x, n = r.y;
+        this.transitionTime(), this.translate({ x: i, y: n }), this.setForceStopped(!0), this.setCallStop(!0), this.hooks.trigger(this.hooks.eventTypes.forceStop, { x: i, y: n });
+      }
+      return e;
+    }, t.prototype.stop = function() {
+      var e = this.doStop();
+      e && this.hooks.trigger(this.hooks.eventTypes.callStop);
+    }, t;
+  }(Zt)
+), Ye = (
+  /** @class */
+  function(o) {
+    it(t, o);
+    function t() {
+      return o !== null && o.apply(this, arguments) || this;
+    }
+    return t.prototype.move = function(e, r, i, n) {
+      if (!i) {
+        this.translate(r), this.options.probeType === 3 && this.hooks.trigger(this.hooks.eventTypes.move, r), this.hooks.trigger(this.hooks.eventTypes.end, r);
+        return;
+      }
+      this.animate(e, r, i, n);
+    }, t.prototype.animate = function(e, r, i, n) {
+      var s = this, l = O(), c = l + i, a = this.options.probeType === 3, h = function() {
+        var u = O();
+        if (u >= c) {
+          s.translate(r), a && s.hooks.trigger(s.hooks.eventTypes.move, r), s.hooks.trigger(s.hooks.eventTypes.end, r);
+          return;
+        }
+        u = (u - l) / i;
+        var f = n(u), y = {};
+        Object.keys(r).forEach(function(v) {
+          var T = e[v], g = r[v];
+          y[v] = (g - T) * f + T;
+        }), s.translate(y), a && s.hooks.trigger(s.hooks.eventTypes.move, y), s.pending && (s.timer = Gt(h)), s.pending || (s.callStopWhenPending ? s.callStopWhenPending = !1 : s.hooks.trigger(s.hooks.eventTypes.end, r));
+      };
+      this.setPending(!0), this.callStopWhenPending && this.setCallStop(!1), I(this.timer), h();
+    }, t.prototype.doStop = function() {
+      var e = this.pending;
+      if (this.setForceStopped(!1), this.setCallStop(!1), e) {
+        this.setPending(!1), I(this.timer);
+        var r = this.translater.getComputedPosition();
+        this.setForceStopped(!0), this.setCallStop(!0), this.hooks.trigger(this.hooks.eventTypes.forceStop, r);
+      }
+      return e;
+    }, t.prototype.stop = function() {
+      var e = this.doStop();
+      e && this.hooks.trigger(this.hooks.eventTypes.callStop);
+    }, t;
+  }(Zt)
+);
+function Xe(o, t, e) {
+  var r = e.useTransition, i = {};
+  return Object.defineProperty(i, "probeType", {
+    enumerable: !0,
+    configurable: !1,
+    get: function() {
+      return e.probeType;
+    }
+  }), r ? new Me(o, t, i) : new Ye(o, t, i);
+}
+var It = (
+  /** @class */
+  function() {
+    function o(t, e, r) {
+      this.wrapper = t, this.options = r, this.hooks = new Y([
+        "beforeComputeBoundary",
+        "computeBoundary",
+        "momentum",
+        "end",
+        "ignoreHasScroll"
+      ]), this.refresh(e);
+    }
+    return o.prototype.start = function() {
+      this.dist = 0, this.setMovingDirection(
+        0
+        /* Default */
+      ), this.setDirection(
+        0
+        /* Default */
+      );
+    }, o.prototype.move = function(t) {
+      return t = this.hasScroll ? t : 0, this.setMovingDirection(t), this.performDampingAlgorithm(t, this.options.outOfBoundaryDampingFactor);
+    }, o.prototype.setMovingDirection = function(t) {
+      this.movingDirection = t > 0 ? -1 : t < 0 ? 1 : 0;
+    }, o.prototype.setDirection = function(t) {
+      this.direction = t > 0 ? -1 : t < 0 ? 1 : 0;
+    }, o.prototype.performDampingAlgorithm = function(t, e) {
+      var r = this.currentPos + t;
+      return (r > this.minScrollPos || r < this.maxScrollPos) && (r > this.minScrollPos && this.options.bounces[0] || r < this.maxScrollPos && this.options.bounces[1] ? r = this.currentPos + t * e : r = r > this.minScrollPos ? this.minScrollPos : this.maxScrollPos), r;
+    }, o.prototype.end = function(t) {
+      var e = {
+        duration: 0
+      }, r = Math.abs(this.currentPos - this.startPos);
+      if (this.options.momentum && t < this.options.momentumLimitTime && r > this.options.momentumLimitDistance) {
+        var i = this.direction === -1 && this.options.bounces[0] || this.direction === 1 && this.options.bounces[1] ? this.wrapperSize : 0;
+        e = this.hasScroll ? this.momentum(this.currentPos, this.startPos, t, this.maxScrollPos, this.minScrollPos, i, this.options) : { destination: this.currentPos, duration: 0 };
+      } else
+        this.hooks.trigger(this.hooks.eventTypes.end, e);
+      return e;
+    }, o.prototype.momentum = function(t, e, r, i, n, s, l) {
+      l === void 0 && (l = this.options);
+      var c = t - e, a = Math.abs(c) / r, h = l.deceleration, u = l.swipeBounceTime, f = l.swipeTime, y = Math.min(f, a * 2 / h), v = {
+        destination: t + a * a / h * (c < 0 ? -1 : 1),
+        duration: y,
+        rate: 15
+      };
+      return this.hooks.trigger(this.hooks.eventTypes.momentum, v, c), v.destination < i ? (v.destination = s ? Math.max(i - s / 4, i - s / v.rate * a) : i, v.duration = u) : v.destination > n && (v.destination = s ? Math.min(n + s / 4, n + s / v.rate * a) : n, v.duration = u), v.destination = Math.round(v.destination), v;
+    }, o.prototype.updateDirection = function() {
+      var t = this.currentPos - this.absStartPos;
+      this.setDirection(t);
+    }, o.prototype.refresh = function(t) {
+      var e = this.options.rect, r = e.size, i = e.position, n = window.getComputedStyle(this.wrapper, null).position === "static", s = _t(this.wrapper);
+      this.wrapperSize = this.wrapper[r === "width" ? "clientWidth" : "clientHeight"], this.setContent(t);
+      var l = _t(this.content);
+      this.contentSize = l[r], this.relativeOffset = l[i], n && (this.relativeOffset -= s[i]), this.computeBoundary(), this.setDirection(
+        0
+        /* Default */
+      );
+    }, o.prototype.setContent = function(t) {
+      t !== this.content && (this.content = t, this.resetState());
+    }, o.prototype.resetState = function() {
+      this.currentPos = 0, this.startPos = 0, this.dist = 0, this.setDirection(
+        0
+        /* Default */
+      ), this.setMovingDirection(
+        0
+        /* Default */
+      ), this.resetStartPos();
+    }, o.prototype.computeBoundary = function() {
+      this.hooks.trigger(this.hooks.eventTypes.beforeComputeBoundary);
+      var t = {
+        minScrollPos: 0,
+        maxScrollPos: this.wrapperSize - this.contentSize
+      };
+      t.maxScrollPos < 0 && (t.maxScrollPos -= this.relativeOffset, this.options.specifiedIndexAsContent === 0 && (t.minScrollPos = -this.relativeOffset)), this.hooks.trigger(this.hooks.eventTypes.computeBoundary, t), this.minScrollPos = t.minScrollPos, this.maxScrollPos = t.maxScrollPos, this.hasScroll = this.options.scrollable && this.maxScrollPos < this.minScrollPos, !this.hasScroll && this.minScrollPos < this.maxScrollPos && (this.maxScrollPos = this.minScrollPos, this.contentSize = this.wrapperSize);
+    }, o.prototype.updatePosition = function(t) {
+      this.currentPos = t;
+    }, o.prototype.getCurrentPos = function() {
+      return this.currentPos;
+    }, o.prototype.checkInBoundary = function() {
+      var t = this.adjustPosition(this.currentPos), e = t === this.getCurrentPos();
+      return {
+        position: t,
+        inBoundary: e
+      };
+    }, o.prototype.adjustPosition = function(t) {
+      return !this.hasScroll && !this.hooks.trigger(this.hooks.eventTypes.ignoreHasScroll) ? t = this.minScrollPos : t > this.minScrollPos ? t = this.minScrollPos : t < this.maxScrollPos && (t = this.maxScrollPos), t;
+    }, o.prototype.updateStartPos = function() {
+      this.startPos = this.currentPos;
+    }, o.prototype.updateAbsStartPos = function() {
+      this.absStartPos = this.currentPos;
+    }, o.prototype.resetStartPos = function() {
+      this.updateStartPos(), this.updateAbsStartPos();
+    }, o.prototype.getAbsDist = function(t) {
+      return this.dist += t, Math.abs(this.dist);
+    }, o.prototype.destroy = function() {
+      this.hooks.destroy();
+    }, o;
+  }()
+), q, G, Z, J, Lt = (q = {}, q.yes = function(o) {
+  return !0;
+}, q.no = function(o) {
+  return $t(o), !1;
+}, q), _e = (G = {}, G.horizontal = (Z = {}, Z.yes = "horizontal", Z.no = "vertical", Z), G.vertical = (J = {}, J.yes = "vertical", J.no = "horizontal", J), G), Oe = (
+  /** @class */
+  function() {
+    function o(t, e, r) {
+      this.directionLockThreshold = t, this.freeScroll = e, this.eventPassthrough = r, this.reset();
+    }
+    return o.prototype.reset = function() {
+      this.directionLocked = "";
+    }, o.prototype.checkMovingDirection = function(t, e, r) {
+      return this.computeDirectionLock(t, e), this.handleEventPassthrough(r);
+    }, o.prototype.adjustDelta = function(t, e) {
+      return this.directionLocked === "horizontal" ? e = 0 : this.directionLocked === "vertical" && (t = 0), {
+        deltaX: t,
+        deltaY: e
+      };
+    }, o.prototype.computeDirectionLock = function(t, e) {
+      this.directionLocked === "" && !this.freeScroll && (t > e + this.directionLockThreshold ? this.directionLocked = "horizontal" : e >= t + this.directionLockThreshold ? this.directionLocked = "vertical" : this.directionLocked = "none");
+    }, o.prototype.handleEventPassthrough = function(t) {
+      var e = _e[this.directionLocked];
+      if (e) {
+        if (this.eventPassthrough === e.yes)
+          return Lt.yes(t);
+        if (this.eventPassthrough === e.no)
+          return Lt.no(t);
+      }
+      return !1;
+    }, o;
+  }()
+), Ie = function(o, t, e) {
+  return e === 2 ? [t, -o] : e === 3 ? [-o, -t] : e === 4 ? [-t, o] : [o, t];
+}, Le = (
+  /** @class */
+  function() {
+    function o(t, e, r, i, n) {
+      this.hooks = new Y([
+        "start",
+        "beforeMove",
+        "scrollStart",
+        "scroll",
+        "beforeEnd",
+        "end",
+        "scrollEnd",
+        "contentNotMoved",
+        "detectMovingDirection",
+        "coordinateTransformation"
+      ]), this.scrollBehaviorX = t, this.scrollBehaviorY = e, this.actionsHandler = r, this.animater = i, this.options = n, this.directionLockAction = new Oe(n.directionLockThreshold, n.freeScroll, n.eventPassthrough), this.enabled = !0, this.bindActionsHandler();
+    }
+    return o.prototype.bindActionsHandler = function() {
+      var t = this;
+      this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.start, function(e) {
+        return t.enabled ? t.handleStart(e) : !0;
+      }), this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.move, function(e) {
+        var r = e.deltaX, i = e.deltaY, n = e.e;
+        if (!t.enabled)
+          return !0;
+        var s = Ie(r, i, t.options.quadrant), l = s[0], c = s[1], a = {
+          deltaX: l,
+          deltaY: c
+        };
+        return t.hooks.trigger(t.hooks.eventTypes.coordinateTransformation, a), t.handleMove(a.deltaX, a.deltaY, n);
+      }), this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.end, function(e) {
+        return t.enabled ? t.handleEnd(e) : !0;
+      }), this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.click, function(e) {
+        t.enabled && !e._constructed && t.handleClick(e);
+      });
+    }, o.prototype.handleStart = function(t) {
+      var e = O();
+      this.fingerMoved = !1, this.contentMoved = !1, this.startTime = e, this.directionLockAction.reset(), this.scrollBehaviorX.start(), this.scrollBehaviorY.start(), this.animater.doStop(), this.scrollBehaviorX.resetStartPos(), this.scrollBehaviorY.resetStartPos(), this.hooks.trigger(this.hooks.eventTypes.start, t);
+    }, o.prototype.handleMove = function(t, e, r) {
+      if (!this.hooks.trigger(this.hooks.eventTypes.beforeMove, r)) {
+        var i = this.scrollBehaviorX.getAbsDist(t), n = this.scrollBehaviorY.getAbsDist(e), s = O();
+        if (this.checkMomentum(i, n, s))
+          return !0;
+        if (this.directionLockAction.checkMovingDirection(i, n, r))
+          return this.actionsHandler.setInitiated(), !0;
+        var l = this.directionLockAction.adjustDelta(t, e), c = this.scrollBehaviorX.getCurrentPos(), a = this.scrollBehaviorX.move(l.deltaX), h = this.scrollBehaviorY.getCurrentPos(), u = this.scrollBehaviorY.move(l.deltaY);
+        if (!this.hooks.trigger(this.hooks.eventTypes.detectMovingDirection)) {
+          this.fingerMoved || (this.fingerMoved = !0);
+          var f = a !== c || u !== h;
+          !this.contentMoved && !f && this.hooks.trigger(this.hooks.eventTypes.contentNotMoved), !this.contentMoved && f && (this.contentMoved = !0, this.hooks.trigger(this.hooks.eventTypes.scrollStart)), this.contentMoved && f && (this.animater.translate({
+            x: a,
+            y: u
+          }), this.dispatchScroll(s));
+        }
+      }
+    }, o.prototype.dispatchScroll = function(t) {
+      t - this.startTime > this.options.momentumLimitTime && (this.startTime = t, this.scrollBehaviorX.updateStartPos(), this.scrollBehaviorY.updateStartPos(), this.options.probeType === 1 && this.hooks.trigger(this.hooks.eventTypes.scroll, this.getCurrentPos())), this.options.probeType > 1 && this.hooks.trigger(this.hooks.eventTypes.scroll, this.getCurrentPos());
+    }, o.prototype.checkMomentum = function(t, e, r) {
+      return r - this.endTime > this.options.momentumLimitTime && e < this.options.momentumLimitDistance && t < this.options.momentumLimitDistance;
+    }, o.prototype.handleEnd = function(t) {
+      if (!this.hooks.trigger(this.hooks.eventTypes.beforeEnd, t)) {
+        var e = this.getCurrentPos();
+        if (this.scrollBehaviorX.updateDirection(), this.scrollBehaviorY.updateDirection(), this.hooks.trigger(this.hooks.eventTypes.end, t, e))
+          return !0;
+        e = this.ensureIntegerPos(e), this.animater.translate(e), this.endTime = O();
+        var r = this.endTime - this.startTime;
+        this.hooks.trigger(this.hooks.eventTypes.scrollEnd, e, r);
+      }
+    }, o.prototype.ensureIntegerPos = function(t) {
+      this.ensuringInteger = !0;
+      var e = t.x, r = t.y, i = this.scrollBehaviorX, n = i.minScrollPos, s = i.maxScrollPos, l = this.scrollBehaviorY, c = l.minScrollPos, a = l.maxScrollPos;
+      return e = e > 0 ? Math.ceil(e) : Math.floor(e), r = r > 0 ? Math.ceil(r) : Math.floor(r), e = Mt(e, s, n), r = Mt(r, a, c), { x: e, y: r };
+    }, o.prototype.handleClick = function(t) {
+      R(t.target, this.options.preventDefaultException) || ($t(t), t.stopPropagation());
+    }, o.prototype.getCurrentPos = function() {
+      return {
+        x: this.scrollBehaviorX.getCurrentPos(),
+        y: this.scrollBehaviorY.getCurrentPos()
+      };
+    }, o.prototype.refresh = function() {
+      this.endTime = 0;
+    }, o.prototype.destroy = function() {
+      this.hooks.destroy();
+    }, o;
+  }()
+);
+function He(o) {
+  var t = [
+    "click",
+    "bindToWrapper",
+    "disableMouse",
+    "disableTouch",
+    "preventDefault",
+    "stopPropagation",
+    "tagException",
+    "preventDefaultException",
+    "autoEndDistance"
+  ].reduce(function(e, r) {
+    return e[r] = o[r], e;
+  }, {});
+  return t;
+}
+function Ht(o, t, e, r) {
+  var i = [
+    "momentum",
+    "momentumLimitTime",
+    "momentumLimitDistance",
+    "deceleration",
+    "swipeBounceTime",
+    "swipeTime",
+    "outOfBoundaryDampingFactor",
+    "specifiedIndexAsContent"
+  ].reduce(function(n, s) {
+    return n[s] = o[s], n;
+  }, {});
+  return i.scrollable = !!o[t], i.bounces = e, i.rect = r, i;
+}
+function kt(o, t, e) {
+  e.forEach(function(r) {
+    var i, n;
+    typeof r == "string" ? i = n = r : (i = r.source, n = r.target), o.on(i, function() {
+      for (var s = [], l = 0; l < arguments.length; l++)
+        s[l] = arguments[l];
+      return t.trigger.apply(t, Nt([n], s));
+    });
+  });
+}
+function Fe(o, t) {
+  for (var e = Object.keys(o), r = 0, i = e; r < i.length; r++) {
+    var n = i[r];
+    if (o[n] !== t[n])
+      return !1;
+  }
+  return !0;
+}
+var Ft = 1, We = (
+  /** @class */
+  function() {
+    function o(t, e, r) {
+      this.wrapper = t, this.content = e, this.resizeTimeout = 0, this.hooks = new Y([
+        "beforeStart",
+        "beforeMove",
+        "beforeScrollStart",
+        "scrollStart",
+        "scroll",
+        "beforeEnd",
+        "scrollEnd",
+        "resize",
+        "touchEnd",
+        "end",
+        "flick",
+        "scrollCancel",
+        "momentum",
+        "scrollTo",
+        "minDistanceScroll",
+        "scrollToElement",
+        "beforeRefresh"
+      ]), this.options = r;
+      var i = this.options.bounce, n = i.left, s = i.right, l = i.top, c = i.bottom;
+      this.scrollBehaviorX = new It(t, e, Ht(r, "scrollX", [n, s], {
+        size: "width",
+        position: "left"
+      })), this.scrollBehaviorY = new It(t, e, Ht(r, "scrollY", [l, c], {
+        size: "height",
+        position: "top"
+      })), this.translater = new xe(this.content), this.animater = Xe(this.content, this.translater, this.options), this.actionsHandler = new Be(this.options.bindToTarget ? this.content : t, He(this.options)), this.actions = new Le(this.scrollBehaviorX, this.scrollBehaviorY, this.actionsHandler, this.animater, this.options);
+      var a = this.resize.bind(this);
+      this.resizeRegister = new et(window, [
+        {
+          name: "orientationchange",
+          handler: a
+        },
+        {
+          name: "resize",
+          handler: a
+        }
+      ]), this.registerTransitionEnd(), this.init();
+    }
+    return o.prototype.init = function() {
+      var t = this;
+      this.bindTranslater(), this.bindAnimater(), this.bindActions(), this.hooks.on(this.hooks.eventTypes.scrollEnd, function() {
+        t.togglePointerEvents(!0);
+      });
+    }, o.prototype.registerTransitionEnd = function() {
+      this.transitionEndRegister = new et(this.content, [
+        {
+          name: _.transitionEnd,
+          handler: this.transitionEnd.bind(this)
+        }
+      ]);
+    }, o.prototype.bindTranslater = function() {
+      var t = this, e = this.translater.hooks;
+      e.on(e.eventTypes.beforeTranslate, function(r) {
+        t.options.translateZ && r.push(t.options.translateZ);
+      }), e.on(e.eventTypes.translate, function(r) {
+        var i = t.getCurrentPos();
+        if (t.updatePositions(r), t.actions.ensuringInteger === !0) {
+          t.actions.ensuringInteger = !1;
+          return;
+        }
+        (r.x !== i.x || r.y !== i.y) && t.togglePointerEvents(!1);
+      });
+    }, o.prototype.bindAnimater = function() {
+      var t = this;
+      this.animater.hooks.on(this.animater.hooks.eventTypes.end, function(e) {
+        t.resetPosition(t.options.bounceTime) || (t.animater.setPending(!1), t.hooks.trigger(t.hooks.eventTypes.scrollEnd, e));
+      }), kt(this.animater.hooks, this.hooks, [
+        {
+          source: this.animater.hooks.eventTypes.move,
+          target: this.hooks.eventTypes.scroll
+        },
+        {
+          source: this.animater.hooks.eventTypes.forceStop,
+          target: this.hooks.eventTypes.scrollEnd
+        }
+      ]);
+    }, o.prototype.bindActions = function() {
+      var t = this, e = this.actions;
+      kt(e.hooks, this.hooks, [
+        {
+          source: e.hooks.eventTypes.start,
+          target: this.hooks.eventTypes.beforeStart
+        },
+        {
+          source: e.hooks.eventTypes.start,
+          target: this.hooks.eventTypes.beforeScrollStart
+        },
+        {
+          source: e.hooks.eventTypes.beforeMove,
+          target: this.hooks.eventTypes.beforeMove
+        },
+        {
+          source: e.hooks.eventTypes.scrollStart,
+          target: this.hooks.eventTypes.scrollStart
+        },
+        {
+          source: e.hooks.eventTypes.scroll,
+          target: this.hooks.eventTypes.scroll
+        },
+        {
+          source: e.hooks.eventTypes.beforeEnd,
+          target: this.hooks.eventTypes.beforeEnd
+        }
+      ]), e.hooks.on(e.hooks.eventTypes.end, function(r, i) {
+        if (t.hooks.trigger(t.hooks.eventTypes.touchEnd, i), t.hooks.trigger(t.hooks.eventTypes.end, i) || !e.fingerMoved && (t.hooks.trigger(t.hooks.eventTypes.scrollCancel), t.checkClick(r)))
+          return !0;
+        if (t.resetPosition(t.options.bounceTime, X.bounce))
+          return t.animater.setForceStopped(!1), !0;
+      }), e.hooks.on(e.hooks.eventTypes.scrollEnd, function(r, i) {
+        var n = Math.abs(r.x - t.scrollBehaviorX.startPos), s = Math.abs(r.y - t.scrollBehaviorY.startPos);
+        if (t.checkFlick(i, n, s)) {
+          t.animater.setForceStopped(!1), t.hooks.trigger(t.hooks.eventTypes.flick);
+          return;
+        }
+        if (t.momentum(r, i)) {
+          t.animater.setForceStopped(!1);
+          return;
+        }
+        e.contentMoved && t.hooks.trigger(t.hooks.eventTypes.scrollEnd, r), t.animater.forceStopped && t.animater.setForceStopped(!1);
+      });
+    }, o.prototype.checkFlick = function(t, e, r) {
+      var i = 1;
+      if (this.hooks.events.flick.length > 1 && t < this.options.flickLimitTime && e < this.options.flickLimitDistance && r < this.options.flickLimitDistance && (r > i || e > i))
+        return !0;
+    }, o.prototype.momentum = function(t, e) {
+      var r = {
+        time: 0,
+        easing: X.swiper,
+        newX: t.x,
+        newY: t.y
+      }, i = this.scrollBehaviorX.end(e), n = this.scrollBehaviorY.end(e);
+      if (r.newX = gt(i.destination) ? r.newX : i.destination, r.newY = gt(n.destination) ? r.newY : n.destination, r.time = Math.max(i.duration, n.duration), this.hooks.trigger(this.hooks.eventTypes.momentum, r, this), r.newX !== t.x || r.newY !== t.y)
+        return (r.newX > this.scrollBehaviorX.minScrollPos || r.newX < this.scrollBehaviorX.maxScrollPos || r.newY > this.scrollBehaviorY.minScrollPos || r.newY < this.scrollBehaviorY.maxScrollPos) && (r.easing = X.swipeBounce), this.scrollTo(r.newX, r.newY, r.time, r.easing), !0;
+    }, o.prototype.checkClick = function(t) {
+      var e = {
+        preventClick: this.animater.forceStopped
+      };
+      if (this.hooks.trigger(this.hooks.eventTypes.checkClick))
+        return this.animater.setForceStopped(!1), !0;
+      if (!e.preventClick) {
+        var r = this.options.dblclick, i = !1;
+        if (r && this.lastClickTime) {
+          var n = r.delay, s = n === void 0 ? 300 : n;
+          O() - this.lastClickTime < s && (i = !0, Se(t));
+        }
+        return this.options.tap && Te(t, this.options.tap), this.options.click && !R(t.target, this.options.preventDefaultException) && Ut(t), this.lastClickTime = i ? null : O(), !0;
+      }
+      return !1;
+    }, o.prototype.resize = function() {
+      var t = this;
+      this.actions.enabled && (ue && (this.wrapper.scrollTop = 0), clearTimeout(this.resizeTimeout), this.resizeTimeout = window.setTimeout(function() {
+        t.hooks.trigger(t.hooks.eventTypes.resize);
+      }, this.options.resizePolling));
+    }, o.prototype.transitionEnd = function(t) {
+      if (!(t.target !== this.content || !this.animater.pending)) {
+        var e = this.animater;
+        e.transitionTime(), this.resetPosition(this.options.bounceTime, X.bounce) || (this.animater.setPending(!1), this.options.probeType !== 3 && this.hooks.trigger(this.hooks.eventTypes.scrollEnd, this.getCurrentPos()));
+      }
+    }, o.prototype.togglePointerEvents = function(t) {
+      t === void 0 && (t = !0);
+      for (var e = this.content.children.length ? this.content.children : [this.content], r = t ? "auto" : "none", i = 0; i < e.length; i++) {
+        var n = e[i];
+        n.isBScrollContainer || (n.style.pointerEvents = r);
+      }
+    }, o.prototype.refresh = function(t) {
+      var e = this.setContent(t);
+      this.hooks.trigger(this.hooks.eventTypes.beforeRefresh), this.scrollBehaviorX.refresh(t), this.scrollBehaviorY.refresh(t), e && (this.translater.setContent(t), this.animater.setContent(t), this.transitionEndRegister.destroy(), this.registerTransitionEnd(), this.options.bindToTarget && this.actionsHandler.setContent(t)), this.actions.refresh(), this.wrapperOffset = Yt(this.wrapper);
+    }, o.prototype.setContent = function(t) {
+      var e = t !== this.content;
+      return e && (this.content = t), e;
+    }, o.prototype.scrollBy = function(t, e, r, i) {
+      r === void 0 && (r = 0);
+      var n = this.getCurrentPos(), s = n.x, l = n.y;
+      i = i || X.bounce, t += s, e += l, this.scrollTo(t, e, r, i);
+    }, o.prototype.scrollTo = function(t, e, r, i, n) {
+      r === void 0 && (r = 0), i === void 0 && (i = X.bounce), n === void 0 && (n = {
+        start: {},
+        end: {}
+      });
+      var s = this.options.useTransition ? i.style : i.fn, l = this.getCurrentPos(), c = N({ x: l.x, y: l.y }, n.start), a = N({
+        x: t,
+        y: e
+      }, n.end);
+      if (this.hooks.trigger(this.hooks.eventTypes.scrollTo, a), !Fe(c, a)) {
+        var h = Math.abs(a.x - c.x), u = Math.abs(a.y - c.y);
+        h < Ft && u < Ft && (r = 0, this.hooks.trigger(this.hooks.eventTypes.minDistanceScroll)), this.animater.move(c, a, r, s);
+      }
+    }, o.prototype.scrollToElement = function(t, e, r, i, n) {
+      var s = Vt(t), l = Yt(s), c = function(h, u, f) {
+        return typeof h == "number" ? h : h ? Math.round(u / 2 - f / 2) : 0;
+      };
+      r = c(r, s.offsetWidth, this.wrapper.offsetWidth), i = c(i, s.offsetHeight, this.wrapper.offsetHeight);
+      var a = function(h, u, f, y) {
+        return h -= u, h = y.adjustPosition(h - f), h;
+      };
+      l.left = a(l.left, this.wrapperOffset.left, r, this.scrollBehaviorX), l.top = a(l.top, this.wrapperOffset.top, i, this.scrollBehaviorY), !this.hooks.trigger(this.hooks.eventTypes.scrollToElement, s, l) && this.scrollTo(l.left, l.top, e, n);
+    }, o.prototype.resetPosition = function(t, e) {
+      t === void 0 && (t = 0), e === void 0 && (e = X.bounce);
+      var r = this.scrollBehaviorX.checkInBoundary(), i = r.position, n = r.inBoundary, s = this.scrollBehaviorY.checkInBoundary(), l = s.position, c = s.inBoundary;
+      return n && c ? !1 : (pe && this.reflow(), this.scrollTo(i, l, t, e), !0);
+    }, o.prototype.reflow = function() {
+      this._reflow = this.content.offsetHeight;
+    }, o.prototype.updatePositions = function(t) {
+      this.scrollBehaviorX.updatePosition(t.x), this.scrollBehaviorY.updatePosition(t.y);
+    }, o.prototype.getCurrentPos = function() {
+      return this.actions.getCurrentPos();
+    }, o.prototype.enable = function() {
+      this.actions.enabled = !0;
+    }, o.prototype.disable = function() {
+      I(this.animater.timer), this.actions.enabled = !1;
+    }, o.prototype.destroy = function() {
+      var t = this, e = [
+        "resizeRegister",
+        "transitionEndRegister",
+        "actionsHandler",
+        "actions",
+        "hooks",
+        "animater",
+        "translater",
+        "scrollBehaviorX",
+        "scrollBehaviorY"
+      ];
+      e.forEach(function(r) {
+        return t[r].destroy();
+      });
+    }, o;
+  }()
+), nt = (
+  /** @class */
+  function(o) {
+    it(t, o);
+    function t(e, r) {
+      var i = o.call(this, [
+        "refresh",
+        "contentChanged",
+        "enable",
+        "disable",
+        "beforeScrollStart",
+        "scrollStart",
+        "scroll",
+        "scrollEnd",
+        "scrollCancel",
+        "touchEnd",
+        "flick",
+        "destroy"
+      ]) || this, n = Vt(e);
+      return n ? (i.plugins = {}, i.options = new De().merge(r).process(), i.setContent(n).valid && (i.hooks = new Y([
+        "refresh",
+        "enable",
+        "disable",
+        "destroy",
+        "beforeInitialScrollTo",
+        "contentChanged"
+      ]), i.init(n)), i) : (tt("Can not resolve the wrapper DOM."), i);
+    }
+    return t.use = function(e) {
+      var r = e.pluginName, i = t.plugins.some(function(n) {
+        return e === n.ctor;
+      });
+      return i ? t : gt(r) ? (tt("Plugin Class must specify plugin's name in static property by 'pluginName' field."), t) : (t.pluginsMap[r] = !0, t.plugins.push({
+        name: r,
+        applyOrder: e.applyOrder,
+        ctor: e
+      }), t);
+    }, t.prototype.setContent = function(e) {
+      var r = !1, i = !0, n = e.children[this.options.specifiedIndexAsContent];
+      return n ? (r = this.content !== n, r && (this.content = n)) : (tt("The wrapper need at least one child element to be content element to scroll."), i = !1), {
+        valid: i,
+        contentChanged: r
+      };
+    }, t.prototype.init = function(e) {
+      var r = this;
+      this.wrapper = e, e.isBScrollContainer = !0, this.scroller = new We(e, this.content, this.options), this.scroller.hooks.on(this.scroller.hooks.eventTypes.resize, function() {
+        r.refresh();
+      }), this.eventBubbling(), this.handleAutoBlur(), this.enable(), this.proxy(ce), this.applyPlugins(), this.refreshWithoutReset(this.content);
+      var i = this.options, n = i.startX, s = i.startY, l = {
+        x: n,
+        y: s
+      };
+      this.hooks.trigger(this.hooks.eventTypes.beforeInitialScrollTo, l) || this.scroller.scrollTo(l.x, l.y);
+    }, t.prototype.applyPlugins = function() {
+      var e = this, r = this.options;
+      t.plugins.sort(function(i, n) {
+        var s, l = (s = {}, s.pre = -1, s.post = 1, s), c = i.applyOrder ? l[i.applyOrder] : 0, a = n.applyOrder ? l[n.applyOrder] : 0;
+        return c - a;
+      }).forEach(function(i) {
+        var n = i.ctor;
+        r[i.name] && typeof n == "function" && (e.plugins[i.name] = new n(e));
+      });
+    }, t.prototype.handleAutoBlur = function() {
+      this.options.autoBlur && this.on(this.eventTypes.beforeScrollStart, function() {
+        var e = document.activeElement;
+        e && (e.tagName === "INPUT" || e.tagName === "TEXTAREA") && e.blur();
+      });
+    }, t.prototype.eventBubbling = function() {
+      kt(this.scroller.hooks, this, [
+        this.eventTypes.beforeScrollStart,
+        this.eventTypes.scrollStart,
+        this.eventTypes.scroll,
+        this.eventTypes.scrollEnd,
+        this.eventTypes.scrollCancel,
+        this.eventTypes.touchEnd,
+        this.eventTypes.flick
+      ]);
+    }, t.prototype.refreshWithoutReset = function(e) {
+      this.scroller.refresh(e), this.hooks.trigger(this.hooks.eventTypes.refresh, e), this.trigger(this.eventTypes.refresh, e);
+    }, t.prototype.proxy = function(e) {
+      var r = this;
+      e.forEach(function(i) {
+        var n = i.key, s = i.sourceKey;
+        Ee(r, s, n);
+      });
+    }, t.prototype.refresh = function() {
+      var e = this.setContent(this.wrapper), r = e.contentChanged, i = e.valid;
+      if (i) {
+        var n = this.content;
+        this.refreshWithoutReset(n), r && (this.hooks.trigger(this.hooks.eventTypes.contentChanged, n), this.trigger(this.eventTypes.contentChanged, n)), this.scroller.resetPosition();
+      }
+    }, t.prototype.enable = function() {
+      this.scroller.enable(), this.hooks.trigger(this.hooks.eventTypes.enable), this.trigger(this.eventTypes.enable);
+    }, t.prototype.disable = function() {
+      this.scroller.disable(), this.hooks.trigger(this.hooks.eventTypes.disable), this.trigger(this.eventTypes.disable);
+    }, t.prototype.destroy = function() {
+      this.hooks.trigger(this.hooks.eventTypes.destroy), this.trigger(this.eventTypes.destroy), this.scroller.destroy();
+    }, t.prototype.eventRegister = function(e) {
+      this.registerType(e);
+    }, t.plugins = [], t.pluginsMap = {}, t;
+  }(Y)
+);
+function V(o, t) {
+  var e = new nt(o, t);
+  return e;
+}
+V.use = nt.use;
+V.plugins = nt.plugins;
+V.pluginsMap = nt.pluginsMap;
+var ze = V;
+/*!
+ * better-scroll / wheel
+ * (c) 2016-2023 ustbhuangyi
+ * Released under the MIT License.
+ */
+var $ = typeof window < "u", ot = $ && navigator.userAgent.toLowerCase();
+ot && ot.indexOf("android") > 0;
+(function() {
+  if (typeof ot == "string") {
+    var o = /os (\d\d?_\d(_\d)?)/, t = o.exec(ot);
+    if (!t)
+      return !1;
+    var e = t[1].split("_").map(function(r) {
+      return parseInt(r, 10);
+    });
+    return e[0] === 13 && e[1] >= 4;
+  }
+  return !1;
+})();
+var Ke = !1;
+if ($) {
+  var Ne = "test-passive";
+  try {
+    var Wt = {};
+    Object.defineProperty(Wt, "passive", {
+      get: function() {
+        Ke = !0;
+      }
+    }), window.addEventListener(Ne, function() {
+    }, Wt);
+  } catch {
+  }
+}
+var Re = function(o, t) {
+  for (var e in t)
+    o[e] = t[e];
+  return o;
+}, Jt = $ && document.createElement("div").style, F = function() {
+  if (!$)
+    return !1;
+  for (var o = [
+    {
+      key: "standard",
+      value: "transform"
+    },
+    {
+      key: "webkit",
+      value: "webkitTransform"
+    },
+    {
+      key: "Moz",
+      value: "MozTransform"
+    },
+    {
+      key: "O",
+      value: "OTransform"
+    },
+    {
+      key: "ms",
+      value: "msTransform"
+    }
+  ], t = 0, e = o; t < e.length; t++) {
+    var r = e[t];
+    if (Jt[r.value] !== void 0)
+      return r.key;
+  }
+  return !1;
+}();
+function x(o) {
+  return F === !1 ? o : F === "standard" ? o === "transitionEnd" ? "transitionend" : o : F + o.charAt(0).toUpperCase() + o.substr(1);
+}
+F && F !== "standard" && "" + F.toLowerCase();
+var Ve = x("transform"), $e = x("transition");
+$ && x("perspective") in Jt;
+var dt = {
+  transform: Ve,
+  transition: $e,
+  transitionTimingFunction: x("transitionTimingFunction"),
+  transitionDuration: x("transitionDuration"),
+  transitionDelay: x("transitionDelay"),
+  transformOrigin: x("transformOrigin"),
+  transitionEnd: x("transitionEnd"),
+  transitionProperty: x("transitionProperty")
+};
+function Q(o, t) {
+  var e = new RegExp("(^|\\s)" + t + "(\\s|$)");
+  return e.test(o.className);
+}
+function je(o) {
+  return Array.prototype.slice.call(o, 0);
+}
+var Ue = {
+  // easeOutQuint
+  swipe: {
+    style: "cubic-bezier(0.23, 1, 0.32, 1)",
+    fn: function(o) {
+      return 1 + --o * o * o * o * o;
+    }
+  },
+  // easeOutQuard
+  swipeBounce: {
+    style: "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
+    fn: function(o) {
+      return o * (2 - o);
+    }
+  },
+  // easeOutQuart
+  bounce: {
+    style: "cubic-bezier(0.165, 0.84, 0.44, 1)",
+    fn: function(o) {
+      return 1 - --o * o * o * o;
+    }
+  }
+}, qe = "plugins.wheel", Ge = [
+  {
+    key: "wheelTo",
+    name: "wheelTo"
+  },
+  {
+    key: "getSelectedIndex",
+    name: "getSelectedIndex"
+  },
+  {
+    key: "restorePosition",
+    name: "restorePosition"
+  }
+], Ze = Ge.map(function(o) {
+  return {
+    key: o.key,
+    sourceKey: qe + "." + o.name
+  };
+}), zt = "wheelIndexChanged", Je = {
+  rate: 4
+}, Qe = (
+  /** @class */
+  function() {
+    function o(t) {
+      this.scroll = t, this.init();
+    }
+    return o.prototype.init = function() {
+      this.handleBScroll(), this.handleOptions(), this.handleHooks(), this.refreshBoundary(), this.setSelectedIndex(this.options.selectedIndex);
+    }, o.prototype.handleBScroll = function() {
+      this.scroll.proxy(Ze), this.scroll.registerType([zt]);
+    }, o.prototype.handleOptions = function() {
+      var t = this.scroll.options.wheel === !0 ? {} : this.scroll.options.wheel, e = {
+        wheelWrapperClass: "wheel-scroll",
+        wheelItemClass: "wheel-item",
+        rotate: 25,
+        adjustTime: 400,
+        selectedIndex: 0,
+        wheelDisabledItemClass: "wheel-disabled-item"
+      };
+      this.options = Re(e, t);
+    }, o.prototype.handleHooks = function() {
+      var t = this, e = this.scroll, r = this.scroll.scroller, i = r.actionsHandler, n = r.scrollBehaviorX, s = r.scrollBehaviorY, l = r.animater, c = r.content;
+      e.on(e.eventTypes.scrollEnd, function(a) {
+        var h = t.findNearestValidWheel(a.y).index;
+        if (r.animater.forceStopped && !t.isAdjustingPosition)
+          return t.target = t.items[h], !0;
+        t.setSelectedIndex(h), t.isAdjustingPosition && (t.isAdjustingPosition = !1);
+      }), this.scroll.hooks.on(this.scroll.hooks.eventTypes.refresh, function(a) {
+        a !== c && (c = a, t.setSelectedIndex(t.options.selectedIndex, !0)), t.rotateX(t.scroll.y), t.wheelTo(t.selectedIndex, 0);
+      }), this.scroll.hooks.on(this.scroll.hooks.eventTypes.beforeInitialScrollTo, function(a) {
+        a.x = 0, a.y = -(t.selectedIndex * t.itemHeight);
+      }), r.hooks.on(r.hooks.eventTypes.checkClick, function() {
+        var a = je(t.items).indexOf(t.target);
+        return a === -1 || t.wheelTo(a, t.options.adjustTime, Ue.swipe), !0;
+      }), r.hooks.on(r.hooks.eventTypes.scrollTo, function(a) {
+        a.y = t.findNearestValidWheel(a.y).y;
+      }), r.hooks.on(r.hooks.eventTypes.minDistanceScroll, function() {
+        var a = r.animater;
+        a.forceStopped === !0 && (a.forceStopped = !1);
+      }), r.hooks.on(r.hooks.eventTypes.scrollToElement, function(a, h) {
+        if (Q(a, t.options.wheelItemClass))
+          h.top = t.findNearestValidWheel(h.top).y;
+        else
+          return !0;
+      }), i.hooks.on(i.hooks.eventTypes.beforeStart, function(a) {
+        t.target = a.target;
+      }), n.hooks.on(n.hooks.eventTypes.computeBoundary, function(a) {
+        a.maxScrollPos = 0, a.minScrollPos = 0;
+      }), s.hooks.on(s.hooks.eventTypes.computeBoundary, function(a) {
+        t.items = t.scroll.scroller.content.children, t.checkWheelAllDisabled(), t.itemHeight = t.items.length > 0 ? s.contentSize / t.items.length : 0, a.maxScrollPos = -t.itemHeight * (t.items.length - 1), a.minScrollPos = 0;
+      }), s.hooks.on(s.hooks.eventTypes.momentum, function(a) {
+        a.rate = Je.rate, a.destination = t.findNearestValidWheel(a.destination).y;
+      }), s.hooks.on(s.hooks.eventTypes.end, function(a) {
+        var h = t.findNearestValidWheel(s.currentPos);
+        a.destination = h.y, a.duration = t.options.adjustTime;
+      }), l.hooks.on(l.hooks.eventTypes.time, function(a) {
+        t.transitionDuration(a);
+      }), l.hooks.on(l.hooks.eventTypes.timeFunction, function(a) {
+        t.timeFunction(a);
+      }), l.hooks.on(l.hooks.eventTypes.callStop, function() {
+        var a = t.findNearestValidWheel(t.scroll.y).index;
+        t.isAdjustingPosition = !0, t.wheelTo(a, 0);
+      }), l.translater.hooks.on(l.translater.hooks.eventTypes.translate, function(a) {
+        t.rotateX(a.y);
+      });
+    }, o.prototype.refreshBoundary = function() {
+      var t = this.scroll.scroller, e = t.scrollBehaviorX, r = t.scrollBehaviorY, i = t.content;
+      e.refresh(i), r.refresh(i);
+    }, o.prototype.setSelectedIndex = function(t, e) {
+      e === void 0 && (e = !1);
+      var r = this.selectedIndex;
+      this.selectedIndex = t, r !== t && !e && this.scroll.trigger(zt, t);
+    }, o.prototype.getSelectedIndex = function() {
+      return this.selectedIndex;
+    }, o.prototype.wheelTo = function(t, e, r) {
+      t === void 0 && (t = 0), e === void 0 && (e = 0);
+      var i = -t * this.itemHeight;
+      this.scroll.scrollTo(0, i, e, r);
+    }, o.prototype.restorePosition = function() {
+      var t = this.scroll.pending;
+      if (t) {
+        var e = this.getSelectedIndex();
+        this.scroll.scroller.animater.clearTimer(), this.wheelTo(e, 0);
+      }
+    }, o.prototype.transitionDuration = function(t) {
+      for (var e = 0; e < this.items.length; e++)
+        this.items[e].style[dt.transitionDuration] = t + "ms";
+    }, o.prototype.timeFunction = function(t) {
+      for (var e = 0; e < this.items.length; e++)
+        this.items[e].style[dt.transitionTimingFunction] = t;
+    }, o.prototype.rotateX = function(t) {
+      for (var e = this.options.rotate, r = e === void 0 ? 25 : e, i = 0; i < this.items.length; i++) {
+        var n = r * (t / this.itemHeight + i), s = n.toFixed(3);
+        this.items[i].style[dt.transform] = "rotateX(" + s + "deg)";
+      }
+    }, o.prototype.findNearestValidWheel = function(t) {
+      t = t > 0 ? 0 : t < this.scroll.maxScrollY ? this.scroll.maxScrollY : t;
+      for (var e = Math.abs(Math.round(-t / this.itemHeight)), r = e, i = this.items, n = this.options.wheelDisabledItemClass; e >= 0 && Q(i[e], n); )
+        e--;
+      if (e < 0)
+        for (e = r; e <= i.length - 1 && Q(i[e], n); )
+          e++;
+      return e === i.length && (e = r), {
+        index: this.wheelItemsAllDisabled ? -1 : e,
+        y: -e * this.itemHeight
+      };
+    }, o.prototype.checkWheelAllDisabled = function() {
+      var t = this.options.wheelDisabledItemClass, e = this.items;
+      this.wheelItemsAllDisabled = !0;
+      for (var r = 0; r < e.length; r++)
+        if (!Q(e[r], t)) {
+          this.wheelItemsAllDisabled = !1;
+          break;
+        }
+    }, o.pluginName = "wheel", o;
+  }()
+);
+const rt = Array.isArray, to = (o) => typeof o == "object" && o !== null;
+function St(o) {
+  return rt(o) && o.length === 3;
+}
+function eo(o) {
+  if (!o) return {};
+  const t = 1900, e = 2100, r = /* @__PURE__ */ new Date(), i = r.getFullYear(), n = r.getMonth() + 1, s = r.getDate(), l = L(i), c = L(n), a = v(t, e), h = v(1, 12), u = C(() => {
+    const m = [4, 6, 9, 11], S = [1, 3, 5, 7, 8, 10, 12], w = m.includes(c.value) ? 30 : S.includes(c.value) ? 31 : y(l.value) ? 29 : 28;
+    return v(1, w);
+  }), f = C(() => [a, h, u.value]);
+  function y(m) {
+    return m % 4 === 0 && (m % 100 !== 0 || m % 400 === 0);
+  }
+  function v(m, S) {
+    const w = [];
+    for (let E = m; E <= S; E++)
+      w.push(E);
+    return w;
+  }
+  function T(m) {
+    return (St(m) ? m : [i, n, s]).map((w, E) => {
+      const j = f.value[E].indexOf(w);
+      return j > -1 ? j : 0;
+    });
+  }
+  function g(m) {
+    const [S, w] = m;
+    l.value = f.value[0][S], c.value = f.value[1][w];
+  }
+  return {
+    selectYear: l,
+    selectMonth: c,
+    dateList: f,
+    updateDateSelect: g,
+    getDateAnchors: T
+  };
+}
+function oo(o) {
+  if (!o) return {};
+  const t = n(0, 23), e = n(0, 59), r = n(0, 59), i = L([]);
+  s();
+  function n(c, a) {
+    const h = [];
+    for (let u = c; u <= a; u++)
+      h.push(`${u}`.padStart(2, "0"));
+    return h;
+  }
+  function s() {
+    const c = /* @__PURE__ */ new Date(), a = c.getHours(), h = c.getMinutes(), u = c.getSeconds();
+    i.value = [a, h, u];
+  }
+  function l(c) {
+    return (St(c) ? c : i.value).map((h) => +h);
+  }
+  return {
+    timeList: [t, e, r],
+    updateDefaultTime: s,
+    getTimeAnchors: l
+  };
+}
+ze.use(Qe);
+function ro(o, t) {
+  const e = L([]), r = L(), i = L([]), n = C(() => o.type === "date"), s = C(() => o.type === "time"), { selectYear: l, selectMonth: c, dateList: a, updateDateSelect: h, getDateAnchors: u } = eo(n.value), { timeList: f, updateDefaultTime: y, getTimeAnchors: v } = oo(s.value), T = C(() => n.value ? u(o.anchor) : s.value ? v(o.anchor) : rt(o.anchor) ? o.anchor : [o.anchor]);
+  async function g(p = !1) {
+    p ? m() : S(), await ne(), e.value.forEach((k, d) => w(d)), !p && j(), te();
+  }
+  function m() {
+    const p = {
+      date: a == null ? void 0 : a.value,
+      time: f
+    }, k = o.type, b = rt(o.data[0]) ? [...o.data] : [o.data];
+    e.value = p[k] ?? b;
+  }
+  function S() {
+    n.value && h(T.value), s.value && !St(o.anchor) && y();
+  }
+  function w(p) {
+    var b;
+    const k = (b = r.value) == null ? void 0 : b.children[p];
+    if (!k) throw new Error("It's not find wheelWrapper");
+    let d = i.value[p];
+    if (d)
+      d.refresh();
+    else {
+      const at = V(k, {
+        wheel: {
+          selectedIndex: 0,
+          rotate: 25
+        },
+        swipeTime: o.swipeTime ?? 500
+      });
+      d = i.value[p] = at, d.on("scrollEnd", () => E(p));
+    }
+    return d;
+  }
+  function E(p) {
+    if (!n.value || p === 2) return;
+    const k = i.value[p].getSelectedIndex(), d = a.value[p][k];
+    p === 0 && (l.value = d), p === 1 && (c.value = d), g(!0);
+  }
+  function j() {
+    i.value.forEach((p, k) => {
+      var b;
+      const d = (b = T.value) == null ? void 0 : b[k];
+      p.wheelTo(d ?? 0);
+    });
+  }
+  function te() {
+    const p = e.value.length;
+    if (i.value.length <= p) return;
+    i.value.splice(p).forEach((d) => d.destroy());
+  }
+  function ee() {
+    t("cancel"), st();
+  }
+  function oe() {
+    i.value.some((b) => b.isInTransition) && re();
+    const { item: k, anchor: d } = ie();
+    t("confirm", k), t("update:anchor", d), st();
+  }
+  function st() {
+    t("update:isShowPicker", !1);
+  }
+  function re() {
+    i.value.forEach((p) => p.stop());
+  }
+  function ie() {
+    const { item: p, anchor: k } = i.value.reduce(
+      (d, b, at) => {
+        const wt = b.getSelectedIndex(), lt = e.value[at][wt];
+        return d.item.push(s.value ? +lt : lt), d.anchor.push(n.value ? lt : wt), d;
+      },
+      { item: [], anchor: [] }
+    );
+    return p.length > 1 ? { item: p, anchor: k } : { item: p[0], anchor: k[0] };
+  }
+  return bt(
+    () => o.data,
+    () => g(!0),
+    { immediate: !0 }
+  ), bt(
+    () => o.isShowPicker,
+    (p) => p && g()
+  ), {
+    pickerData: e,
+    wheelWrapper: r,
+    cancel: ee,
+    confirm: oe,
+    closePicker: st
+  };
+}
+const Qt = (o) => (ae("data-v-f4d0313e"), o = o(), le(), o), io = { class: "picker" }, no = { class: "picker_title" }, so = { class: "picker_panel" }, ao = /* @__PURE__ */ Qt(() => /* @__PURE__ */ P("div", { class: "picker_mask_top" }, null, -1)), lo = /* @__PURE__ */ Qt(() => /* @__PURE__ */ P("div", { class: "picker_mask_bottom" }, null, -1)), co = { class: "picker_wheel_scroll" }, ho = /* @__PURE__ */ se({
+  __name: "Picker",
+  props: {
+    data: { default: () => [] },
+    isShowPicker: { type: Boolean, default: !1 },
+    options: { default: () => ({}) },
+    anchor: {},
+    showKey: {},
+    swipeTime: { default: 500 },
+    type: { default: "" }
+  },
+  emits: ["update:isShowPicker", "update:anchor", "cancel", "confirm"],
+  setup(o, { emit: t }) {
+    const e = o, r = t, i = C(() => ({
+      cancelClass: "",
+      confirmClass: "",
+      titleClass: "",
+      cancelColor: "#999",
+      confirmColor: "#42b983",
+      titleColor: "",
+      cancelText: "Cancel",
+      confirmText: "Confirm",
+      titleText: "",
+      ...e.options
+    })), n = C(() => i.value.cancelColor), s = C(() => i.value.confirmColor), l = C(() => i.value.titleColor), c = C(() => rt(e.showKey) ? e.showKey : [e.showKey]), { pickerData: a, wheelWrapper: h, cancel: u, confirm: f, closePicker: y } = ro(e, r);
+    return (v, T) => (z(), K(ct, null, [
+      Pt(Et, { name: "fade" }, {
+        default: Ct(() => [
+          Dt(P("div", {
+            class: "mask",
+            onClick: T[0] || (T[0] = //@ts-ignore
+            (...g) => A(y) && A(y)(...g))
+          }, null, 512), [
+            [Bt, v.isShowPicker]
+          ])
+        ]),
+        _: 1
+      }),
+      Pt(Et, { name: "slide" }, {
+        default: Ct(() => [
+          Dt(P("div", io, [
+            P("div", no, [
+              P("button", {
+                class: ht(["picker_cancel", i.value.cancelClass]),
+                style: ut({ color: n.value }),
+                onClick: T[1] || (T[1] = //@ts-ignore
+                (...g) => A(u) && A(u)(...g))
+              }, U(i.value.cancelText), 7),
+              P("button", {
+                class: ht(["picker_confirm", i.value.confirmClass]),
+                style: ut({ color: s.value }),
+                onClick: T[2] || (T[2] = //@ts-ignore
+                (...g) => A(f) && A(f)(...g))
+              }, U(i.value.confirmText), 7),
+              P("h4", {
+                class: ht([i.value.titleClass]),
+                style: ut({ color: l.value })
+              }, U(i.value.titleText), 7)
+            ]),
+            P("div", so, [
+              ao,
+              lo,
+              P("div", {
+                ref_key: "wheelWrapper",
+                ref: h,
+                class: "picker_wheel_wrapper"
+              }, [
+                (z(!0), K(ct, null, xt(A(a), (g, m) => (z(), K("div", {
+                  key: m,
+                  class: "picker_wheel"
+                }, [
+                  P("ul", co, [
+                    (z(!0), K(ct, null, xt(g, (S, w) => {
+                      var E;
+                      return z(), K("li", {
+                        key: w,
+                        class: "picker_wheel_item"
+                      }, U((E = c.value) != null && E[m] && A(to)(S) ? S[c.value[m]] : S), 1);
+                    }), 128))
+                  ])
+                ]))), 128))
+              ], 512)
+            ])
+          ], 512), [
+            [Bt, v.isShowPicker]
+          ])
+        ]),
+        _: 1
+      })
+    ], 64));
+  }
+}), uo = (o, t) => {
+  const e = o.__vccOpts || o;
+  for (const [r, i] of t)
+    e[r] = i;
+  return e;
+}, Kt = /* @__PURE__ */ uo(ho, [["__scopeId", "data-v-f4d0313e"]]);
+Kt.install = function(o) {
+  o.component("Picker", Kt);
+};
+export {
+  Kt as default
+};