@component-hook/picker 0.1.5 → 0.2.0-alpha.0

package/dist/react/picker.es.js

@@ -0,0 +1,3797 @@
+import "./index.css";
+import me, { useState as Xe, useMemo as We, useRef as _t, useEffect as Ke } from "react";
+import Ge from "react-dom";
+function fn(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var Rt = { exports: {} }, Le = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var er;
+function hn() {
+  if (er) return Le;
+  er = 1;
+  var r = me, e = Symbol.for("react.element"), t = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, o = r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, i = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function a(c, u, l) {
+    var f, p = {}, E = null, w = null;
+    l !== void 0 && (E = "" + l), u.key !== void 0 && (E = "" + u.key), u.ref !== void 0 && (w = u.ref);
+    for (f in u) n.call(u, f) && !i.hasOwnProperty(f) && (p[f] = u[f]);
+    if (c && c.defaultProps) for (f in u = c.defaultProps, u) p[f] === void 0 && (p[f] = u[f]);
+    return { $$typeof: e, type: c, key: E, ref: w, props: p, _owner: o.current };
+  }
+  return Le.Fragment = t, Le.jsx = a, Le.jsxs = a, Le;
+}
+var Fe = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var tr;
+function pn() {
+  return tr || (tr = 1, process.env.NODE_ENV !== "production" && function() {
+    var r = me, e = Symbol.for("react.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), a = Symbol.for("react.provider"), c = Symbol.for("react.context"), u = Symbol.for("react.forward_ref"), l = Symbol.for("react.suspense"), f = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), E = Symbol.for("react.lazy"), w = Symbol.for("react.offscreen"), R = Symbol.iterator, I = "@@iterator";
+    function Y(s) {
+      if (s === null || typeof s != "object")
+        return null;
+      var h = R && s[R] || s[I];
+      return typeof h == "function" ? h : null;
+    }
+    var $ = r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function D(s) {
+      {
+        for (var h = arguments.length, m = new Array(h > 1 ? h - 1 : 0), x = 1; x < h; x++)
+          m[x - 1] = arguments[x];
+        H("error", s, m);
+      }
+    }
+    function H(s, h, m) {
+      {
+        var x = $.ReactDebugCurrentFrame, N = x.getStackAddendum();
+        N !== "" && (h += "%s", m = m.concat([N]));
+        var W = m.map(function(B) {
+          return String(B);
+        });
+        W.unshift("Warning: " + h), Function.prototype.apply.call(console[s], console, W);
+      }
+    }
+    var X = !1, v = !1, te = !1, Z = !1, V = !1, re;
+    re = Symbol.for("react.module.reference");
+    function oe(s) {
+      return !!(typeof s == "string" || typeof s == "function" || s === n || s === i || V || s === o || s === l || s === f || Z || s === w || X || v || te || typeof s == "object" && s !== null && (s.$$typeof === E || s.$$typeof === p || s.$$typeof === a || s.$$typeof === c || s.$$typeof === u || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      s.$$typeof === re || s.getModuleId !== void 0));
+    }
+    function ue(s, h, m) {
+      var x = s.displayName;
+      if (x)
+        return x;
+      var N = h.displayName || h.name || "";
+      return N !== "" ? m + "(" + N + ")" : m;
+    }
+    function ie(s) {
+      return s.displayName || "Context";
+    }
+    function q(s) {
+      if (s == null)
+        return null;
+      if (typeof s.tag == "number" && D("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof s == "function")
+        return s.displayName || s.name || null;
+      if (typeof s == "string")
+        return s;
+      switch (s) {
+        case n:
+          return "Fragment";
+        case t:
+          return "Portal";
+        case i:
+          return "Profiler";
+        case o:
+          return "StrictMode";
+        case l:
+          return "Suspense";
+        case f:
+          return "SuspenseList";
+      }
+      if (typeof s == "object")
+        switch (s.$$typeof) {
+          case c:
+            var h = s;
+            return ie(h) + ".Consumer";
+          case a:
+            var m = s;
+            return ie(m._context) + ".Provider";
+          case u:
+            return ue(s, s.render, "ForwardRef");
+          case p:
+            var x = s.displayName || null;
+            return x !== null ? x : q(s.type) || "Memo";
+          case E: {
+            var N = s, W = N._payload, B = N._init;
+            try {
+              return q(B(W));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var K = Object.assign, se = 0, Q, ae, de, fe, d, g, T;
+    function k() {
+    }
+    k.__reactDisabledLog = !0;
+    function b() {
+      {
+        if (se === 0) {
+          Q = console.log, ae = console.info, de = console.warn, fe = console.error, d = console.group, g = console.groupCollapsed, T = console.groupEnd;
+          var s = {
+            configurable: !0,
+            enumerable: !0,
+            value: k,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: s,
+            log: s,
+            warn: s,
+            error: s,
+            group: s,
+            groupCollapsed: s,
+            groupEnd: s
+          });
+        }
+        se++;
+      }
+    }
+    function P() {
+      {
+        if (se--, se === 0) {
+          var s = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: K({}, s, {
+              value: Q
+            }),
+            info: K({}, s, {
+              value: ae
+            }),
+            warn: K({}, s, {
+              value: de
+            }),
+            error: K({}, s, {
+              value: fe
+            }),
+            group: K({}, s, {
+              value: d
+            }),
+            groupCollapsed: K({}, s, {
+              value: g
+            }),
+            groupEnd: K({}, s, {
+              value: T
+            })
+          });
+        }
+        se < 0 && D("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var S = $.ReactCurrentDispatcher, C;
+    function O(s, h, m) {
+      {
+        if (C === void 0)
+          try {
+            throw Error();
+          } catch (N) {
+            var x = N.stack.trim().match(/\n( *(at )?)/);
+            C = x && x[1] || "";
+          }
+        return `
+` + C + s;
+      }
+    }
+    var j = !1, A;
+    {
+      var G = typeof WeakMap == "function" ? WeakMap : Map;
+      A = new G();
+    }
+    function y(s, h) {
+      if (!s || j)
+        return "";
+      {
+        var m = A.get(s);
+        if (m !== void 0)
+          return m;
+      }
+      var x;
+      j = !0;
+      var N = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var W;
+      W = S.current, S.current = null, b();
+      try {
+        if (h) {
+          var B = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(B.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(B, []);
+            } catch (ne) {
+              x = ne;
+            }
+            Reflect.construct(s, [], B);
+          } else {
+            try {
+              B.call();
+            } catch (ne) {
+              x = ne;
+            }
+            s.call(B.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (ne) {
+            x = ne;
+          }
+          s();
+        }
+      } catch (ne) {
+        if (ne && x && typeof ne.stack == "string") {
+          for (var M = ne.stack.split(`
+`), ee = x.stack.split(`
+`), z = M.length - 1, U = ee.length - 1; z >= 1 && U >= 0 && M[z] !== ee[U]; )
+            U--;
+          for (; z >= 1 && U >= 0; z--, U--)
+            if (M[z] !== ee[U]) {
+              if (z !== 1 || U !== 1)
+                do
+                  if (z--, U--, U < 0 || M[z] !== ee[U]) {
+                    var le = `
+` + M[z].replace(" at new ", " at ");
+                    return s.displayName && le.includes("<anonymous>") && (le = le.replace("<anonymous>", s.displayName)), typeof s == "function" && A.set(s, le), le;
+                  }
+                while (z >= 1 && U >= 0);
+              break;
+            }
+        }
+      } finally {
+        j = !1, S.current = W, P(), Error.prepareStackTrace = N;
+      }
+      var Re = s ? s.displayName || s.name : "", be = Re ? O(Re) : "";
+      return typeof s == "function" && A.set(s, be), be;
+    }
+    function ce(s, h, m) {
+      return y(s, !1);
+    }
+    function Oe(s) {
+      var h = s.prototype;
+      return !!(h && h.isReactComponent);
+    }
+    function Ee(s, h, m) {
+      if (s == null)
+        return "";
+      if (typeof s == "function")
+        return y(s, Oe(s));
+      if (typeof s == "string")
+        return O(s);
+      switch (s) {
+        case l:
+          return O("Suspense");
+        case f:
+          return O("SuspenseList");
+      }
+      if (typeof s == "object")
+        switch (s.$$typeof) {
+          case u:
+            return ce(s.render);
+          case p:
+            return Ee(s.type, h, m);
+          case E: {
+            var x = s, N = x._payload, W = x._init;
+            try {
+              return Ee(W(N), h, m);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var je = Object.prototype.hasOwnProperty, $t = {}, Xt = $.ReactDebugCurrentFrame;
+    function qe(s) {
+      if (s) {
+        var h = s._owner, m = Ee(s.type, s._source, h ? h.type : null);
+        Xt.setExtraStackFrame(m);
+      } else
+        Xt.setExtraStackFrame(null);
+    }
+    function Xr(s, h, m, x, N) {
+      {
+        var W = Function.call.bind(je);
+        for (var B in s)
+          if (W(s, B)) {
+            var M = void 0;
+            try {
+              if (typeof s[B] != "function") {
+                var ee = Error((x || "React class") + ": " + m + " type `" + B + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof s[B] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw ee.name = "Invariant Violation", ee;
+              }
+              M = s[B](h, B, x, m, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (z) {
+              M = z;
+            }
+            M && !(M instanceof Error) && (qe(N), D("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", x || "React class", m, B, typeof M), qe(null)), M instanceof Error && !(M.message in $t) && ($t[M.message] = !0, qe(N), D("Failed %s type: %s", m, M.message), qe(null));
+          }
+      }
+    }
+    var Wr = Array.isArray;
+    function ft(s) {
+      return Wr(s);
+    }
+    function Hr(s) {
+      {
+        var h = typeof Symbol == "function" && Symbol.toStringTag, m = h && s[Symbol.toStringTag] || s.constructor.name || "Object";
+        return m;
+      }
+    }
+    function zr(s) {
+      try {
+        return Wt(s), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Wt(s) {
+      return "" + s;
+    }
+    function Ht(s) {
+      if (zr(s))
+        return D("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Hr(s)), Wt(s);
+    }
+    var Ne = $.ReactCurrentOwner, Ur = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, zt, Ut, ht;
+    ht = {};
+    function Vr(s) {
+      if (je.call(s, "ref")) {
+        var h = Object.getOwnPropertyDescriptor(s, "ref").get;
+        if (h && h.isReactWarning)
+          return !1;
+      }
+      return s.ref !== void 0;
+    }
+    function qr(s) {
+      if (je.call(s, "key")) {
+        var h = Object.getOwnPropertyDescriptor(s, "key").get;
+        if (h && h.isReactWarning)
+          return !1;
+      }
+      return s.key !== void 0;
+    }
+    function Kr(s, h) {
+      if (typeof s.ref == "string" && Ne.current && h && Ne.current.stateNode !== h) {
+        var m = q(Ne.current.type);
+        ht[m] || (D('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', q(Ne.current.type), s.ref), ht[m] = !0);
+      }
+    }
+    function Gr(s, h) {
+      {
+        var m = function() {
+          zt || (zt = !0, D("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", h));
+        };
+        m.isReactWarning = !0, Object.defineProperty(s, "key", {
+          get: m,
+          configurable: !0
+        });
+      }
+    }
+    function Jr(s, h) {
+      {
+        var m = function() {
+          Ut || (Ut = !0, D("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", h));
+        };
+        m.isReactWarning = !0, Object.defineProperty(s, "ref", {
+          get: m,
+          configurable: !0
+        });
+      }
+    }
+    var Zr = function(s, h, m, x, N, W, B) {
+      var M = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: e,
+        // Built-in properties that belong on the element
+        type: s,
+        key: h,
+        ref: m,
+        props: B,
+        // Record the component responsible for creating this element.
+        _owner: W
+      };
+      return M._store = {}, Object.defineProperty(M._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(M, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: x
+      }), Object.defineProperty(M, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: N
+      }), Object.freeze && (Object.freeze(M.props), Object.freeze(M)), M;
+    };
+    function Qr(s, h, m, x, N) {
+      {
+        var W, B = {}, M = null, ee = null;
+        m !== void 0 && (Ht(m), M = "" + m), qr(h) && (Ht(h.key), M = "" + h.key), Vr(h) && (ee = h.ref, Kr(h, N));
+        for (W in h)
+          je.call(h, W) && !Ur.hasOwnProperty(W) && (B[W] = h[W]);
+        if (s && s.defaultProps) {
+          var z = s.defaultProps;
+          for (W in z)
+            B[W] === void 0 && (B[W] = z[W]);
+        }
+        if (M || ee) {
+          var U = typeof s == "function" ? s.displayName || s.name || "Unknown" : s;
+          M && Gr(B, U), ee && Jr(B, U);
+        }
+        return Zr(s, M, ee, N, x, Ne.current, B);
+      }
+    }
+    var pt = $.ReactCurrentOwner, Vt = $.ReactDebugCurrentFrame;
+    function _e(s) {
+      if (s) {
+        var h = s._owner, m = Ee(s.type, s._source, h ? h.type : null);
+        Vt.setExtraStackFrame(m);
+      } else
+        Vt.setExtraStackFrame(null);
+    }
+    var dt;
+    dt = !1;
+    function vt(s) {
+      return typeof s == "object" && s !== null && s.$$typeof === e;
+    }
+    function qt() {
+      {
+        if (pt.current) {
+          var s = q(pt.current.type);
+          if (s)
+            return `
+
+Check the render method of \`` + s + "`.";
+        }
+        return "";
+      }
+    }
+    function en(s) {
+      return "";
+    }
+    var Kt = {};
+    function tn(s) {
+      {
+        var h = qt();
+        if (!h) {
+          var m = typeof s == "string" ? s : s.displayName || s.name;
+          m && (h = `
+
+Check the top-level render call using <` + m + ">.");
+        }
+        return h;
+      }
+    }
+    function Gt(s, h) {
+      {
+        if (!s._store || s._store.validated || s.key != null)
+          return;
+        s._store.validated = !0;
+        var m = tn(h);
+        if (Kt[m])
+          return;
+        Kt[m] = !0;
+        var x = "";
+        s && s._owner && s._owner !== pt.current && (x = " It was passed a child from " + q(s._owner.type) + "."), _e(s), D('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', m, x), _e(null);
+      }
+    }
+    function Jt(s, h) {
+      {
+        if (typeof s != "object")
+          return;
+        if (ft(s))
+          for (var m = 0; m < s.length; m++) {
+            var x = s[m];
+            vt(x) && Gt(x, h);
+          }
+        else if (vt(s))
+          s._store && (s._store.validated = !0);
+        else if (s) {
+          var N = Y(s);
+          if (typeof N == "function" && N !== s.entries)
+            for (var W = N.call(s), B; !(B = W.next()).done; )
+              vt(B.value) && Gt(B.value, h);
+        }
+      }
+    }
+    function rn(s) {
+      {
+        var h = s.type;
+        if (h == null || typeof h == "string")
+          return;
+        var m;
+        if (typeof h == "function")
+          m = h.propTypes;
+        else if (typeof h == "object" && (h.$$typeof === u || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        h.$$typeof === p))
+          m = h.propTypes;
+        else
+          return;
+        if (m) {
+          var x = q(h);
+          Xr(m, s.props, "prop", x, s);
+        } else if (h.PropTypes !== void 0 && !dt) {
+          dt = !0;
+          var N = q(h);
+          D("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", N || "Unknown");
+        }
+        typeof h.getDefaultProps == "function" && !h.getDefaultProps.isReactClassApproved && D("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function nn(s) {
+      {
+        for (var h = Object.keys(s.props), m = 0; m < h.length; m++) {
+          var x = h[m];
+          if (x !== "children" && x !== "key") {
+            _e(s), D("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", x), _e(null);
+            break;
+          }
+        }
+        s.ref !== null && (_e(s), D("Invalid attribute `ref` supplied to `React.Fragment`."), _e(null));
+      }
+    }
+    var Zt = {};
+    function Qt(s, h, m, x, N, W) {
+      {
+        var B = oe(s);
+        if (!B) {
+          var M = "";
+          (s === void 0 || typeof s == "object" && s !== null && Object.keys(s).length === 0) && (M += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var ee = en();
+          ee ? M += ee : M += qt();
+          var z;
+          s === null ? z = "null" : ft(s) ? z = "array" : s !== void 0 && s.$$typeof === e ? (z = "<" + (q(s.type) || "Unknown") + " />", M = " Did you accidentally export a JSX literal instead of a component?") : z = typeof s, D("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", z, M);
+        }
+        var U = Qr(s, h, m, N, W);
+        if (U == null)
+          return U;
+        if (B) {
+          var le = h.children;
+          if (le !== void 0)
+            if (x)
+              if (ft(le)) {
+                for (var Re = 0; Re < le.length; Re++)
+                  Jt(le[Re], s);
+                Object.freeze && Object.freeze(le);
+              } else
+                D("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Jt(le, s);
+        }
+        if (je.call(h, "key")) {
+          var be = q(s), ne = Object.keys(h).filter(function(un) {
+            return un !== "key";
+          }), yt = ne.length > 0 ? "{key: someKey, " + ne.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Zt[be + yt]) {
+            var ln = ne.length > 0 ? "{" + ne.join(": ..., ") + ": ...}" : "{}";
+            D(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, yt, be, ln, be), Zt[be + yt] = !0;
+          }
+        }
+        return s === n ? nn(U) : rn(U), U;
+      }
+    }
+    function on(s, h, m) {
+      return Qt(s, h, m, !0);
+    }
+    function sn(s, h, m) {
+      return Qt(s, h, m, !1);
+    }
+    var an = sn, cn = on;
+    Fe.Fragment = n, Fe.jsx = an, Fe.jsxs = cn;
+  }()), Fe;
+}
+process.env.NODE_ENV === "production" ? Rt.exports = hn() : Rt.exports = pn();
+var J = Rt.exports;
+function ot() {
+  return ot = Object.assign ? Object.assign.bind() : function(r) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var n in t) ({}).hasOwnProperty.call(t, n) && (r[n] = t[n]);
+    }
+    return r;
+  }, ot.apply(null, arguments);
+}
+function xr(r, e) {
+  if (r == null) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function Dt(r, e) {
+  return Dt = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t, n) {
+    return t.__proto__ = n, t;
+  }, Dt(r, e);
+}
+function Cr(r, e) {
+  r.prototype = Object.create(e.prototype), r.prototype.constructor = r, Dt(r, e);
+}
+var At = { exports: {} }, Je = { exports: {} }, L = {};
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var rr;
+function dn() {
+  if (rr) return L;
+  rr = 1;
+  var r = typeof Symbol == "function" && Symbol.for, e = r ? Symbol.for("react.element") : 60103, t = r ? Symbol.for("react.portal") : 60106, n = r ? Symbol.for("react.fragment") : 60107, o = r ? Symbol.for("react.strict_mode") : 60108, i = r ? Symbol.for("react.profiler") : 60114, a = r ? Symbol.for("react.provider") : 60109, c = r ? Symbol.for("react.context") : 60110, u = r ? Symbol.for("react.async_mode") : 60111, l = r ? Symbol.for("react.concurrent_mode") : 60111, f = r ? Symbol.for("react.forward_ref") : 60112, p = r ? Symbol.for("react.suspense") : 60113, E = r ? Symbol.for("react.suspense_list") : 60120, w = r ? Symbol.for("react.memo") : 60115, R = r ? Symbol.for("react.lazy") : 60116, I = r ? Symbol.for("react.block") : 60121, Y = r ? Symbol.for("react.fundamental") : 60117, $ = r ? Symbol.for("react.responder") : 60118, D = r ? Symbol.for("react.scope") : 60119;
+  function H(v) {
+    if (typeof v == "object" && v !== null) {
+      var te = v.$$typeof;
+      switch (te) {
+        case e:
+          switch (v = v.type, v) {
+            case u:
+            case l:
+            case n:
+            case i:
+            case o:
+            case p:
+              return v;
+            default:
+              switch (v = v && v.$$typeof, v) {
+                case c:
+                case f:
+                case R:
+                case w:
+                case a:
+                  return v;
+                default:
+                  return te;
+              }
+          }
+        case t:
+          return te;
+      }
+    }
+  }
+  function X(v) {
+    return H(v) === l;
+  }
+  return L.AsyncMode = u, L.ConcurrentMode = l, L.ContextConsumer = c, L.ContextProvider = a, L.Element = e, L.ForwardRef = f, L.Fragment = n, L.Lazy = R, L.Memo = w, L.Portal = t, L.Profiler = i, L.StrictMode = o, L.Suspense = p, L.isAsyncMode = function(v) {
+    return X(v) || H(v) === u;
+  }, L.isConcurrentMode = X, L.isContextConsumer = function(v) {
+    return H(v) === c;
+  }, L.isContextProvider = function(v) {
+    return H(v) === a;
+  }, L.isElement = function(v) {
+    return typeof v == "object" && v !== null && v.$$typeof === e;
+  }, L.isForwardRef = function(v) {
+    return H(v) === f;
+  }, L.isFragment = function(v) {
+    return H(v) === n;
+  }, L.isLazy = function(v) {
+    return H(v) === R;
+  }, L.isMemo = function(v) {
+    return H(v) === w;
+  }, L.isPortal = function(v) {
+    return H(v) === t;
+  }, L.isProfiler = function(v) {
+    return H(v) === i;
+  }, L.isStrictMode = function(v) {
+    return H(v) === o;
+  }, L.isSuspense = function(v) {
+    return H(v) === p;
+  }, L.isValidElementType = function(v) {
+    return typeof v == "string" || typeof v == "function" || v === n || v === l || v === i || v === o || v === p || v === E || typeof v == "object" && v !== null && (v.$$typeof === R || v.$$typeof === w || v.$$typeof === a || v.$$typeof === c || v.$$typeof === f || v.$$typeof === Y || v.$$typeof === $ || v.$$typeof === D || v.$$typeof === I);
+  }, L.typeOf = H, L;
+}
+var F = {};
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var nr;
+function vn() {
+  return nr || (nr = 1, process.env.NODE_ENV !== "production" && function() {
+    var r = typeof Symbol == "function" && Symbol.for, e = r ? Symbol.for("react.element") : 60103, t = r ? Symbol.for("react.portal") : 60106, n = r ? Symbol.for("react.fragment") : 60107, o = r ? Symbol.for("react.strict_mode") : 60108, i = r ? Symbol.for("react.profiler") : 60114, a = r ? Symbol.for("react.provider") : 60109, c = r ? Symbol.for("react.context") : 60110, u = r ? Symbol.for("react.async_mode") : 60111, l = r ? Symbol.for("react.concurrent_mode") : 60111, f = r ? Symbol.for("react.forward_ref") : 60112, p = r ? Symbol.for("react.suspense") : 60113, E = r ? Symbol.for("react.suspense_list") : 60120, w = r ? Symbol.for("react.memo") : 60115, R = r ? Symbol.for("react.lazy") : 60116, I = r ? Symbol.for("react.block") : 60121, Y = r ? Symbol.for("react.fundamental") : 60117, $ = r ? Symbol.for("react.responder") : 60118, D = r ? Symbol.for("react.scope") : 60119;
+    function H(y) {
+      return typeof y == "string" || typeof y == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      y === n || y === l || y === i || y === o || y === p || y === E || typeof y == "object" && y !== null && (y.$$typeof === R || y.$$typeof === w || y.$$typeof === a || y.$$typeof === c || y.$$typeof === f || y.$$typeof === Y || y.$$typeof === $ || y.$$typeof === D || y.$$typeof === I);
+    }
+    function X(y) {
+      if (typeof y == "object" && y !== null) {
+        var ce = y.$$typeof;
+        switch (ce) {
+          case e:
+            var Oe = y.type;
+            switch (Oe) {
+              case u:
+              case l:
+              case n:
+              case i:
+              case o:
+              case p:
+                return Oe;
+              default:
+                var Ee = Oe && Oe.$$typeof;
+                switch (Ee) {
+                  case c:
+                  case f:
+                  case R:
+                  case w:
+                  case a:
+                    return Ee;
+                  default:
+                    return ce;
+                }
+            }
+          case t:
+            return ce;
+        }
+      }
+    }
+    var v = u, te = l, Z = c, V = a, re = e, oe = f, ue = n, ie = R, q = w, K = t, se = i, Q = o, ae = p, de = !1;
+    function fe(y) {
+      return de || (de = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), d(y) || X(y) === u;
+    }
+    function d(y) {
+      return X(y) === l;
+    }
+    function g(y) {
+      return X(y) === c;
+    }
+    function T(y) {
+      return X(y) === a;
+    }
+    function k(y) {
+      return typeof y == "object" && y !== null && y.$$typeof === e;
+    }
+    function b(y) {
+      return X(y) === f;
+    }
+    function P(y) {
+      return X(y) === n;
+    }
+    function S(y) {
+      return X(y) === R;
+    }
+    function C(y) {
+      return X(y) === w;
+    }
+    function O(y) {
+      return X(y) === t;
+    }
+    function j(y) {
+      return X(y) === i;
+    }
+    function A(y) {
+      return X(y) === o;
+    }
+    function G(y) {
+      return X(y) === p;
+    }
+    F.AsyncMode = v, F.ConcurrentMode = te, F.ContextConsumer = Z, F.ContextProvider = V, F.Element = re, F.ForwardRef = oe, F.Fragment = ue, F.Lazy = ie, F.Memo = q, F.Portal = K, F.Profiler = se, F.StrictMode = Q, F.Suspense = ae, F.isAsyncMode = fe, F.isConcurrentMode = d, F.isContextConsumer = g, F.isContextProvider = T, F.isElement = k, F.isForwardRef = b, F.isFragment = P, F.isLazy = S, F.isMemo = C, F.isPortal = O, F.isProfiler = j, F.isStrictMode = A, F.isSuspense = G, F.isValidElementType = H, F.typeOf = X;
+  }()), F;
+}
+var or;
+function wr() {
+  return or || (or = 1, process.env.NODE_ENV === "production" ? Je.exports = dn() : Je.exports = vn()), Je.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var mt, ir;
+function yn() {
+  if (ir) return mt;
+  ir = 1;
+  var r = Object.getOwnPropertySymbols, e = Object.prototype.hasOwnProperty, t = Object.prototype.propertyIsEnumerable;
+  function n(i) {
+    if (i == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(i);
+  }
+  function o() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var i = new String("abc");
+      if (i[5] = "de", Object.getOwnPropertyNames(i)[0] === "5")
+        return !1;
+      for (var a = {}, c = 0; c < 10; c++)
+        a["_" + String.fromCharCode(c)] = c;
+      var u = Object.getOwnPropertyNames(a).map(function(f) {
+        return a[f];
+      });
+      if (u.join("") !== "0123456789")
+        return !1;
+      var l = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(f) {
+        l[f] = f;
+      }), Object.keys(Object.assign({}, l)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return mt = o() ? Object.assign : function(i, a) {
+    for (var c, u = n(i), l, f = 1; f < arguments.length; f++) {
+      c = Object(arguments[f]);
+      for (var p in c)
+        e.call(c, p) && (u[p] = c[p]);
+      if (r) {
+        l = r(c);
+        for (var E = 0; E < l.length; E++)
+          t.call(c, l[E]) && (u[l[E]] = c[l[E]]);
+      }
+    }
+    return u;
+  }, mt;
+}
+var gt, sr;
+function Nt() {
+  if (sr) return gt;
+  sr = 1;
+  var r = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return gt = r, gt;
+}
+var Tt, ar;
+function Or() {
+  return ar || (ar = 1, Tt = Function.call.bind(Object.prototype.hasOwnProperty)), Tt;
+}
+var Et, cr;
+function mn() {
+  if (cr) return Et;
+  cr = 1;
+  var r = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var e = Nt(), t = {}, n = Or();
+    r = function(i) {
+      var a = "Warning: " + i;
+      typeof console < "u" && console.error(a);
+      try {
+        throw new Error(a);
+      } catch {
+      }
+    };
+  }
+  function o(i, a, c, u, l) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var f in i)
+        if (n(i, f)) {
+          var p;
+          try {
+            if (typeof i[f] != "function") {
+              var E = Error(
+                (u || "React class") + ": " + c + " type `" + f + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof i[f] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw E.name = "Invariant Violation", E;
+            }
+            p = i[f](a, f, u, c, null, e);
+          } catch (R) {
+            p = R;
+          }
+          if (p && !(p instanceof Error) && r(
+            (u || "React class") + ": type specification of " + c + " `" + f + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof p + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), p instanceof Error && !(p.message in t)) {
+            t[p.message] = !0;
+            var w = l ? l() : "";
+            r(
+              "Failed " + c + " type: " + p.message + (w ?? "")
+            );
+          }
+        }
+    }
+  }
+  return o.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (t = {});
+  }, Et = o, Et;
+}
+var bt, lr;
+function gn() {
+  if (lr) return bt;
+  lr = 1;
+  var r = wr(), e = yn(), t = Nt(), n = Or(), o = mn(), i = function() {
+  };
+  process.env.NODE_ENV !== "production" && (i = function(c) {
+    var u = "Warning: " + c;
+    typeof console < "u" && console.error(u);
+    try {
+      throw new Error(u);
+    } catch {
+    }
+  });
+  function a() {
+    return null;
+  }
+  return bt = function(c, u) {
+    var l = typeof Symbol == "function" && Symbol.iterator, f = "@@iterator";
+    function p(d) {
+      var g = d && (l && d[l] || d[f]);
+      if (typeof g == "function")
+        return g;
+    }
+    var E = "<<anonymous>>", w = {
+      array: $("array"),
+      bigint: $("bigint"),
+      bool: $("boolean"),
+      func: $("function"),
+      number: $("number"),
+      object: $("object"),
+      string: $("string"),
+      symbol: $("symbol"),
+      any: D(),
+      arrayOf: H,
+      element: X(),
+      elementType: v(),
+      instanceOf: te,
+      node: oe(),
+      objectOf: V,
+      oneOf: Z,
+      oneOfType: re,
+      shape: ie,
+      exact: q
+    };
+    function R(d, g) {
+      return d === g ? d !== 0 || 1 / d === 1 / g : d !== d && g !== g;
+    }
+    function I(d, g) {
+      this.message = d, this.data = g && typeof g == "object" ? g : {}, this.stack = "";
+    }
+    I.prototype = Error.prototype;
+    function Y(d) {
+      if (process.env.NODE_ENV !== "production")
+        var g = {}, T = 0;
+      function k(P, S, C, O, j, A, G) {
+        if (O = O || E, A = A || C, G !== t) {
+          if (u) {
+            var y = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw y.name = "Invariant Violation", y;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var ce = O + ":" + C;
+            !g[ce] && // Avoid spamming the console because they are often not actionable except for lib authors
+            T < 3 && (i(
+              "You are manually calling a React.PropTypes validation function for the `" + A + "` prop on `" + O + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), g[ce] = !0, T++);
+          }
+        }
+        return S[C] == null ? P ? S[C] === null ? new I("The " + j + " `" + A + "` is marked as required " + ("in `" + O + "`, but its value is `null`.")) : new I("The " + j + " `" + A + "` is marked as required in " + ("`" + O + "`, but its value is `undefined`.")) : null : d(S, C, O, j, A);
+      }
+      var b = k.bind(null, !1);
+      return b.isRequired = k.bind(null, !0), b;
+    }
+    function $(d) {
+      function g(T, k, b, P, S, C) {
+        var O = T[k], j = Q(O);
+        if (j !== d) {
+          var A = ae(O);
+          return new I(
+            "Invalid " + P + " `" + S + "` of type " + ("`" + A + "` supplied to `" + b + "`, expected ") + ("`" + d + "`."),
+            { expectedType: d }
+          );
+        }
+        return null;
+      }
+      return Y(g);
+    }
+    function D() {
+      return Y(a);
+    }
+    function H(d) {
+      function g(T, k, b, P, S) {
+        if (typeof d != "function")
+          return new I("Property `" + S + "` of component `" + b + "` has invalid PropType notation inside arrayOf.");
+        var C = T[k];
+        if (!Array.isArray(C)) {
+          var O = Q(C);
+          return new I("Invalid " + P + " `" + S + "` of type " + ("`" + O + "` supplied to `" + b + "`, expected an array."));
+        }
+        for (var j = 0; j < C.length; j++) {
+          var A = d(C, j, b, P, S + "[" + j + "]", t);
+          if (A instanceof Error)
+            return A;
+        }
+        return null;
+      }
+      return Y(g);
+    }
+    function X() {
+      function d(g, T, k, b, P) {
+        var S = g[T];
+        if (!c(S)) {
+          var C = Q(S);
+          return new I("Invalid " + b + " `" + P + "` of type " + ("`" + C + "` supplied to `" + k + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return Y(d);
+    }
+    function v() {
+      function d(g, T, k, b, P) {
+        var S = g[T];
+        if (!r.isValidElementType(S)) {
+          var C = Q(S);
+          return new I("Invalid " + b + " `" + P + "` of type " + ("`" + C + "` supplied to `" + k + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return Y(d);
+    }
+    function te(d) {
+      function g(T, k, b, P, S) {
+        if (!(T[k] instanceof d)) {
+          var C = d.name || E, O = fe(T[k]);
+          return new I("Invalid " + P + " `" + S + "` of type " + ("`" + O + "` supplied to `" + b + "`, expected ") + ("instance of `" + C + "`."));
+        }
+        return null;
+      }
+      return Y(g);
+    }
+    function Z(d) {
+      if (!Array.isArray(d))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? i(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : i("Invalid argument supplied to oneOf, expected an array.")), a;
+      function g(T, k, b, P, S) {
+        for (var C = T[k], O = 0; O < d.length; O++)
+          if (R(C, d[O]))
+            return null;
+        var j = JSON.stringify(d, function(G, y) {
+          var ce = ae(y);
+          return ce === "symbol" ? String(y) : y;
+        });
+        return new I("Invalid " + P + " `" + S + "` of value `" + String(C) + "` " + ("supplied to `" + b + "`, expected one of " + j + "."));
+      }
+      return Y(g);
+    }
+    function V(d) {
+      function g(T, k, b, P, S) {
+        if (typeof d != "function")
+          return new I("Property `" + S + "` of component `" + b + "` has invalid PropType notation inside objectOf.");
+        var C = T[k], O = Q(C);
+        if (O !== "object")
+          return new I("Invalid " + P + " `" + S + "` of type " + ("`" + O + "` supplied to `" + b + "`, expected an object."));
+        for (var j in C)
+          if (n(C, j)) {
+            var A = d(C, j, b, P, S + "." + j, t);
+            if (A instanceof Error)
+              return A;
+          }
+        return null;
+      }
+      return Y(g);
+    }
+    function re(d) {
+      if (!Array.isArray(d))
+        return process.env.NODE_ENV !== "production" && i("Invalid argument supplied to oneOfType, expected an instance of array."), a;
+      for (var g = 0; g < d.length; g++) {
+        var T = d[g];
+        if (typeof T != "function")
+          return i(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + de(T) + " at index " + g + "."
+          ), a;
+      }
+      function k(b, P, S, C, O) {
+        for (var j = [], A = 0; A < d.length; A++) {
+          var G = d[A], y = G(b, P, S, C, O, t);
+          if (y == null)
+            return null;
+          y.data && n(y.data, "expectedType") && j.push(y.data.expectedType);
+        }
+        var ce = j.length > 0 ? ", expected one of type [" + j.join(", ") + "]" : "";
+        return new I("Invalid " + C + " `" + O + "` supplied to " + ("`" + S + "`" + ce + "."));
+      }
+      return Y(k);
+    }
+    function oe() {
+      function d(g, T, k, b, P) {
+        return K(g[T]) ? null : new I("Invalid " + b + " `" + P + "` supplied to " + ("`" + k + "`, expected a ReactNode."));
+      }
+      return Y(d);
+    }
+    function ue(d, g, T, k, b) {
+      return new I(
+        (d || "React class") + ": " + g + " type `" + T + "." + k + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + b + "`."
+      );
+    }
+    function ie(d) {
+      function g(T, k, b, P, S) {
+        var C = T[k], O = Q(C);
+        if (O !== "object")
+          return new I("Invalid " + P + " `" + S + "` of type `" + O + "` " + ("supplied to `" + b + "`, expected `object`."));
+        for (var j in d) {
+          var A = d[j];
+          if (typeof A != "function")
+            return ue(b, P, S, j, ae(A));
+          var G = A(C, j, b, P, S + "." + j, t);
+          if (G)
+            return G;
+        }
+        return null;
+      }
+      return Y(g);
+    }
+    function q(d) {
+      function g(T, k, b, P, S) {
+        var C = T[k], O = Q(C);
+        if (O !== "object")
+          return new I("Invalid " + P + " `" + S + "` of type `" + O + "` " + ("supplied to `" + b + "`, expected `object`."));
+        var j = e({}, T[k], d);
+        for (var A in j) {
+          var G = d[A];
+          if (n(d, A) && typeof G != "function")
+            return ue(b, P, S, A, ae(G));
+          if (!G)
+            return new I(
+              "Invalid " + P + " `" + S + "` key `" + A + "` supplied to `" + b + "`.\nBad object: " + JSON.stringify(T[k], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(d), null, "  ")
+            );
+          var y = G(C, A, b, P, S + "." + A, t);
+          if (y)
+            return y;
+        }
+        return null;
+      }
+      return Y(g);
+    }
+    function K(d) {
+      switch (typeof d) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !d;
+        case "object":
+          if (Array.isArray(d))
+            return d.every(K);
+          if (d === null || c(d))
+            return !0;
+          var g = p(d);
+          if (g) {
+            var T = g.call(d), k;
+            if (g !== d.entries) {
+              for (; !(k = T.next()).done; )
+                if (!K(k.value))
+                  return !1;
+            } else
+              for (; !(k = T.next()).done; ) {
+                var b = k.value;
+                if (b && !K(b[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function se(d, g) {
+      return d === "symbol" ? !0 : g ? g["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && g instanceof Symbol : !1;
+    }
+    function Q(d) {
+      var g = typeof d;
+      return Array.isArray(d) ? "array" : d instanceof RegExp ? "object" : se(g, d) ? "symbol" : g;
+    }
+    function ae(d) {
+      if (typeof d > "u" || d === null)
+        return "" + d;
+      var g = Q(d);
+      if (g === "object") {
+        if (d instanceof Date)
+          return "date";
+        if (d instanceof RegExp)
+          return "regexp";
+      }
+      return g;
+    }
+    function de(d) {
+      var g = ae(d);
+      switch (g) {
+        case "array":
+        case "object":
+          return "an " + g;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + g;
+        default:
+          return g;
+      }
+    }
+    function fe(d) {
+      return !d.constructor || !d.constructor.name ? E : d.constructor.name;
+    }
+    return w.checkPropTypes = o, w.resetWarningCache = o.resetWarningCache, w.PropTypes = w, w;
+  }, bt;
+}
+var kt, ur;
+function Tn() {
+  if (ur) return kt;
+  ur = 1;
+  var r = Nt();
+  function e() {
+  }
+  function t() {
+  }
+  return t.resetWarningCache = e, kt = function() {
+    function n(a, c, u, l, f, p) {
+      if (p !== r) {
+        var E = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw E.name = "Invariant Violation", E;
+      }
+    }
+    n.isRequired = n;
+    function o() {
+      return n;
+    }
+    var i = {
+      array: n,
+      bigint: n,
+      bool: n,
+      func: n,
+      number: n,
+      object: n,
+      string: n,
+      symbol: n,
+      any: n,
+      arrayOf: o,
+      element: n,
+      elementType: n,
+      instanceOf: o,
+      node: n,
+      objectOf: o,
+      oneOf: o,
+      oneOfType: o,
+      shape: o,
+      exact: o,
+      checkPropTypes: t,
+      resetWarningCache: e
+    };
+    return i.PropTypes = i, i;
+  }, kt;
+}
+if (process.env.NODE_ENV !== "production") {
+  var En = wr(), bn = !0;
+  At.exports = gn()(En.isElement, bn);
+} else
+  At.exports = Tn()();
+var kn = At.exports;
+const _ = /* @__PURE__ */ fn(kn);
+function Sn(r, e) {
+  return r.classList ? !!e && r.classList.contains(e) : (" " + (r.className.baseVal || r.className) + " ").indexOf(" " + e + " ") !== -1;
+}
+function Pn(r, e) {
+  r.classList ? r.classList.add(e) : Sn(r, e) || (typeof r.className == "string" ? r.className = r.className + " " + e : r.setAttribute("class", (r.className && r.className.baseVal || "") + " " + e));
+}
+function fr(r, e) {
+  return r.replace(new RegExp("(^|\\s)" + e + "(?:\\s|$)", "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
+}
+function xn(r, e) {
+  r.classList ? r.classList.remove(e) : typeof r.className == "string" ? r.className = fr(r.className, e) : r.setAttribute("class", fr(r.className && r.className.baseVal || "", e));
+}
+const hr = {
+  disabled: !1
+};
+var Cn = process.env.NODE_ENV !== "production" ? _.oneOfType([_.number, _.shape({
+  enter: _.number,
+  exit: _.number,
+  appear: _.number
+}).isRequired]) : null, wn = process.env.NODE_ENV !== "production" ? _.oneOfType([_.string, _.shape({
+  enter: _.string,
+  exit: _.string,
+  active: _.string
+}), _.shape({
+  enter: _.string,
+  enterDone: _.string,
+  enterActive: _.string,
+  exit: _.string,
+  exitDone: _.string,
+  exitActive: _.string
+})]) : null;
+const _r = me.createContext(null);
+var Rr = function(e) {
+  return e.scrollTop;
+}, $e = "unmounted", Se = "exited", Pe = "entering", Me = "entered", Mt = "exiting", he = /* @__PURE__ */ function(r) {
+  Cr(e, r);
+  function e(n, o) {
+    var i;
+    i = r.call(this, n, o) || this;
+    var a = o, c = a && !a.isMounting ? n.enter : n.appear, u;
+    return i.appearStatus = null, n.in ? c ? (u = Se, i.appearStatus = Pe) : u = Me : n.unmountOnExit || n.mountOnEnter ? u = $e : u = Se, i.state = {
+      status: u
+    }, i.nextCallback = null, i;
+  }
+  e.getDerivedStateFromProps = function(o, i) {
+    var a = o.in;
+    return a && i.status === $e ? {
+      status: Se
+    } : null;
+  };
+  var t = e.prototype;
+  return t.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, t.componentDidUpdate = function(o) {
+    var i = null;
+    if (o !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== Pe && a !== Me && (i = Pe) : (a === Pe || a === Me) && (i = Mt);
+    }
+    this.updateStatus(!1, i);
+  }, t.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, t.getTimeouts = function() {
+    var o = this.props.timeout, i, a, c;
+    return i = a = c = o, o != null && typeof o != "number" && (i = o.exit, a = o.enter, c = o.appear !== void 0 ? o.appear : a), {
+      exit: i,
+      enter: a,
+      appear: c
+    };
+  }, t.updateStatus = function(o, i) {
+    if (o === void 0 && (o = !1), i !== null)
+      if (this.cancelNextCallback(), i === Pe) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : Ge.findDOMNode(this);
+          a && Rr(a);
+        }
+        this.performEnter(o);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === Se && this.setState({
+      status: $e
+    });
+  }, t.performEnter = function(o) {
+    var i = this, a = this.props.enter, c = this.context ? this.context.isMounting : o, u = this.props.nodeRef ? [c] : [Ge.findDOMNode(this), c], l = u[0], f = u[1], p = this.getTimeouts(), E = c ? p.appear : p.enter;
+    if (!o && !a || hr.disabled) {
+      this.safeSetState({
+        status: Me
+      }, function() {
+        i.props.onEntered(l);
+      });
+      return;
+    }
+    this.props.onEnter(l, f), this.safeSetState({
+      status: Pe
+    }, function() {
+      i.props.onEntering(l, f), i.onTransitionEnd(E, function() {
+        i.safeSetState({
+          status: Me
+        }, function() {
+          i.props.onEntered(l, f);
+        });
+      });
+    });
+  }, t.performExit = function() {
+    var o = this, i = this.props.exit, a = this.getTimeouts(), c = this.props.nodeRef ? void 0 : Ge.findDOMNode(this);
+    if (!i || hr.disabled) {
+      this.safeSetState({
+        status: Se
+      }, function() {
+        o.props.onExited(c);
+      });
+      return;
+    }
+    this.props.onExit(c), this.safeSetState({
+      status: Mt
+    }, function() {
+      o.props.onExiting(c), o.onTransitionEnd(a.exit, function() {
+        o.safeSetState({
+          status: Se
+        }, function() {
+          o.props.onExited(c);
+        });
+      });
+    });
+  }, t.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, t.safeSetState = function(o, i) {
+    i = this.setNextCallback(i), this.setState(o, i);
+  }, t.setNextCallback = function(o) {
+    var i = this, a = !0;
+    return this.nextCallback = function(c) {
+      a && (a = !1, i.nextCallback = null, o(c));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, t.onTransitionEnd = function(o, i) {
+    this.setNextCallback(i);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : Ge.findDOMNode(this), c = o == null && !this.props.addEndListener;
+    if (!a || c) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var u = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], l = u[0], f = u[1];
+      this.props.addEndListener(l, f);
+    }
+    o != null && setTimeout(this.nextCallback, o);
+  }, t.render = function() {
+    var o = this.state.status;
+    if (o === $e)
+      return null;
+    var i = this.props, a = i.children;
+    i.in, i.mountOnEnter, i.unmountOnExit, i.appear, i.enter, i.exit, i.timeout, i.addEndListener, i.onEnter, i.onEntering, i.onEntered, i.onExit, i.onExiting, i.onExited, i.nodeRef;
+    var c = xr(i, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ me.createElement(_r.Provider, {
+        value: null
+      }, typeof a == "function" ? a(o, c) : me.cloneElement(me.Children.only(a), c))
+    );
+  }, e;
+}(me.Component);
+he.contextType = _r;
+he.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: _.shape({
+    current: typeof Element > "u" ? _.any : function(r, e, t, n, o, i) {
+      var a = r[e];
+      return _.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(r, e, t, n, o, i);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: _.oneOfType([_.func.isRequired, _.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: _.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: _.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: _.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: _.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: _.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: _.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(e) {
+    var t = Cn;
+    e.addEndListener || (t = t.isRequired);
+    for (var n = arguments.length, o = new Array(n > 1 ? n - 1 : 0), i = 1; i < n; i++)
+      o[i - 1] = arguments[i];
+    return t.apply(void 0, [e].concat(o));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: _.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: _.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: _.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: _.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: _.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: _.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: _.func
+} : {};
+function De() {
+}
+he.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: De,
+  onEntering: De,
+  onEntered: De,
+  onExit: De,
+  onExiting: De,
+  onExited: De
+};
+he.UNMOUNTED = $e;
+he.EXITED = Se;
+he.ENTERING = Pe;
+he.ENTERED = Me;
+he.EXITING = Mt;
+var On = function(e, t) {
+  return e && t && t.split(" ").forEach(function(n) {
+    return Pn(e, n);
+  });
+}, St = function(e, t) {
+  return e && t && t.split(" ").forEach(function(n) {
+    return xn(e, n);
+  });
+}, it = /* @__PURE__ */ function(r) {
+  Cr(e, r);
+  function e() {
+    for (var n, o = arguments.length, i = new Array(o), a = 0; a < o; a++)
+      i[a] = arguments[a];
+    return n = r.call.apply(r, [this].concat(i)) || this, n.appliedClasses = {
+      appear: {},
+      enter: {},
+      exit: {}
+    }, n.onEnter = function(c, u) {
+      var l = n.resolveArguments(c, u), f = l[0], p = l[1];
+      n.removeClasses(f, "exit"), n.addClass(f, p ? "appear" : "enter", "base"), n.props.onEnter && n.props.onEnter(c, u);
+    }, n.onEntering = function(c, u) {
+      var l = n.resolveArguments(c, u), f = l[0], p = l[1], E = p ? "appear" : "enter";
+      n.addClass(f, E, "active"), n.props.onEntering && n.props.onEntering(c, u);
+    }, n.onEntered = function(c, u) {
+      var l = n.resolveArguments(c, u), f = l[0], p = l[1], E = p ? "appear" : "enter";
+      n.removeClasses(f, E), n.addClass(f, E, "done"), n.props.onEntered && n.props.onEntered(c, u);
+    }, n.onExit = function(c) {
+      var u = n.resolveArguments(c), l = u[0];
+      n.removeClasses(l, "appear"), n.removeClasses(l, "enter"), n.addClass(l, "exit", "base"), n.props.onExit && n.props.onExit(c);
+    }, n.onExiting = function(c) {
+      var u = n.resolveArguments(c), l = u[0];
+      n.addClass(l, "exit", "active"), n.props.onExiting && n.props.onExiting(c);
+    }, n.onExited = function(c) {
+      var u = n.resolveArguments(c), l = u[0];
+      n.removeClasses(l, "exit"), n.addClass(l, "exit", "done"), n.props.onExited && n.props.onExited(c);
+    }, n.resolveArguments = function(c, u) {
+      return n.props.nodeRef ? [n.props.nodeRef.current, c] : [c, u];
+    }, n.getClassNames = function(c) {
+      var u = n.props.classNames, l = typeof u == "string", f = l && u ? u + "-" : "", p = l ? "" + f + c : u[c], E = l ? p + "-active" : u[c + "Active"], w = l ? p + "-done" : u[c + "Done"];
+      return {
+        baseClassName: p,
+        activeClassName: E,
+        doneClassName: w
+      };
+    }, n;
+  }
+  var t = e.prototype;
+  return t.addClass = function(o, i, a) {
+    var c = this.getClassNames(i)[a + "ClassName"], u = this.getClassNames("enter"), l = u.doneClassName;
+    i === "appear" && a === "done" && l && (c += " " + l), a === "active" && o && Rr(o), c && (this.appliedClasses[i][a] = c, On(o, c));
+  }, t.removeClasses = function(o, i) {
+    var a = this.appliedClasses[i], c = a.base, u = a.active, l = a.done;
+    this.appliedClasses[i] = {}, c && St(o, c), u && St(o, u), l && St(o, l);
+  }, t.render = function() {
+    var o = this.props;
+    o.classNames;
+    var i = xr(o, ["classNames"]);
+    return /* @__PURE__ */ me.createElement(he, ot({}, i, {
+      onEnter: this.onEnter,
+      onEntered: this.onEntered,
+      onEntering: this.onEntering,
+      onExit: this.onExit,
+      onExiting: this.onExiting,
+      onExited: this.onExited
+    }));
+  }, e;
+}(me.Component);
+it.defaultProps = {
+  classNames: ""
+};
+it.propTypes = process.env.NODE_ENV !== "production" ? ot({}, he.propTypes, {
+  /**
+   * The animation classNames applied to the component as it appears, enters,
+   * exits or has finished the transition. A single name can be provided, which
+   * will be suffixed for each stage, e.g. `classNames="fade"` applies:
+   *
+   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`
+   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`
+   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`
+   *
+   * A few details to note about how these classes are applied:
+   *
+   * 1. They are _joined_ with the ones that are already defined on the child
+   *    component, so if you want to add some base styles, you can use
+   *    `className` without worrying that it will be overridden.
+   *
+   * 2. If the transition component mounts with `in={false}`, no classes are
+   *    applied yet. You might be expecting `*-exit-done`, but if you think
+   *    about it, a component cannot finish exiting if it hasn't entered yet.
+   *
+   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This
+   *    allows you to define different behavior for when appearing is done and
+   *    when regular entering is done, using selectors like
+   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply
+   *    an epic entrance animation when element first appears in the DOM using
+   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can
+   *    simply use `fade-enter-done` for defining both cases.
+   *
+   * Each individual classNames can also be specified independently like:
+   *
+   * ```js
+   * classNames={{
+   *  appear: 'my-appear',
+   *  appearActive: 'my-active-appear',
+   *  appearDone: 'my-done-appear',
+   *  enter: 'my-enter',
+   *  enterActive: 'my-active-enter',
+   *  enterDone: 'my-done-enter',
+   *  exit: 'my-exit',
+   *  exitActive: 'my-active-exit',
+   *  exitDone: 'my-done-exit',
+   * }}
+   * ```
+   *
+   * If you want to set these classes using CSS Modules:
+   *
+   * ```js
+   * import styles from './styles.css';
+   * ```
+   *
+   * you might want to use camelCase in your CSS file, that way could simply
+   * spread them instead of listing them one by one:
+   *
+   * ```js
+   * classNames={{ ...styles }}
+   * ```
+   *
+   * @type {string | {
+   *  appear?: string,
+   *  appearActive?: string,
+   *  appearDone?: string,
+   *  enter?: string,
+   *  enterActive?: string,
+   *  enterDone?: string,
+   *  exit?: string,
+   *  exitActive?: string,
+   *  exitDone?: string,
+   * }}
+   */
+  classNames: wn,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEnter: _.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter-active' or
+   * 'appear-active' class is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: _.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or
+   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntered: _.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExit: _.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExiting: _.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' classes
+   * are **removed** and the `exit-done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExited: _.func
+}) : {};
+/*!
+ * 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 It = function(r, e) {
+  return It = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, n) {
+    t.__proto__ = n;
+  } || function(t, n) {
+    for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
+  }, It(r, e);
+};
+function lt(r, e) {
+  It(r, e);
+  function t() {
+    this.constructor = r;
+  }
+  r.prototype = e === null ? Object.create(e) : (t.prototype = e.prototype, new t());
+}
+var He = function() {
+  return He = Object.assign || function(e) {
+    for (var t, n = 1, o = arguments.length; n < o; n++) {
+      t = arguments[n];
+      for (var i in t) Object.prototype.hasOwnProperty.call(t, i) && (e[i] = t[i]);
+    }
+    return e;
+  }, He.apply(this, arguments);
+};
+function Dr() {
+  for (var r = 0, e = 0, t = arguments.length; e < t; e++) r += arguments[e].length;
+  for (var n = Array(r), o = 0, e = 0; e < t; e++)
+    for (var i = arguments[e], a = 0, c = i.length; a < c; a++, o++)
+      n[o] = i[a];
+  return n;
+}
+var _n = [
+  {
+    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 nt(r) {
+  console.error("[BScroll warn]: " + r);
+}
+var pe = typeof window < "u", Ye = pe && navigator.userAgent.toLowerCase(), Rn = !!(Ye && /wechatdevtools/.test(Ye)), Dn = Ye && Ye.indexOf("android") > 0, An = function() {
+  if (typeof Ye == "string") {
+    var r = /os (\d\d?_\d(_\d)?)/, e = r.exec(Ye);
+    if (!e)
+      return !1;
+    var t = e[1].split("_").map(function(n) {
+      return parseInt(n, 10);
+    });
+    return t[0] === 13 && t[1] >= 4;
+  }
+  return !1;
+}(), Ar = !1;
+if (pe) {
+  var Mn = "test-passive";
+  try {
+    var pr = {};
+    Object.defineProperty(pr, "passive", {
+      get: function() {
+        Ar = !0;
+      }
+    }), window.addEventListener(Mn, function() {
+    }, pr);
+  } catch {
+  }
+}
+function Ce() {
+  return window.performance && window.performance.now && window.performance.timing ? window.performance.now() + window.performance.timing.navigationStart : +/* @__PURE__ */ new Date();
+}
+var Bt = function(r, e) {
+  for (var t in e)
+    r[t] = e[t];
+  return r;
+};
+function Yt(r) {
+  return r == null;
+}
+function dr(r, e, t) {
+  return r < e ? e : r > t ? t : r;
+}
+var Lt = pe && document.createElement("div").style, Ie = function() {
+  if (!pe)
+    return !1;
+  for (var r = [
+    {
+      key: "standard",
+      value: "transform"
+    },
+    {
+      key: "webkit",
+      value: "webkitTransform"
+    },
+    {
+      key: "Moz",
+      value: "MozTransform"
+    },
+    {
+      key: "O",
+      value: "OTransform"
+    },
+    {
+      key: "ms",
+      value: "msTransform"
+    }
+  ], e = 0, t = r; e < t.length; e++) {
+    var n = t[e];
+    if (Lt[n.value] !== void 0)
+      return n.key;
+  }
+  return !1;
+}();
+function ve(r) {
+  return Ie === !1 ? r : Ie === "standard" ? r === "transitionEnd" ? "transitionend" : r : Ie + r.charAt(0).toUpperCase() + r.substr(1);
+}
+function Mr(r) {
+  return typeof r == "string" ? document.querySelector(r) : r;
+}
+function In(r, e, t, n) {
+  var o = Ar ? {
+    passive: !1,
+    capture: !!n
+  } : !!n;
+  r.addEventListener(e, t, o);
+}
+function Bn(r, e, t, n) {
+  r.removeEventListener(e, t, {
+    capture: !!n
+  });
+}
+function Ir(r) {
+  r.cancelable && r.preventDefault();
+}
+function vr(r) {
+  for (var e = 0, t = 0; r; )
+    e -= r.offsetLeft, t -= r.offsetTop, r = r.offsetParent;
+  return {
+    left: e,
+    top: t
+  };
+}
+Ie && Ie !== "standard" && "" + Ie.toLowerCase();
+var Yn = ve("transform"), Br = ve("transition"), jn = pe && ve("perspective") in Lt, yr = pe && ("ontouchstart" in window || Rn), Nn = pe && Br in Lt, xe = {
+  transform: Yn,
+  transition: Br,
+  transitionTimingFunction: ve("transitionTimingFunction"),
+  transitionDuration: ve("transitionDuration"),
+  transitionDelay: ve("transitionDelay"),
+  transformOrigin: ve("transformOrigin"),
+  transitionEnd: ve("transitionEnd"),
+  transitionProperty: ve("transitionProperty")
+}, Pt = {
+  touchstart: 1,
+  touchmove: 1,
+  touchend: 1,
+  touchcancel: 1,
+  mousedown: 2,
+  mousemove: 2,
+  mouseup: 2
+};
+function mr(r) {
+  if (r instanceof window.SVGElement) {
+    var e = r.getBoundingClientRect();
+    return {
+      top: e.top,
+      left: e.left,
+      width: e.width,
+      height: e.height
+    };
+  } else
+    return {
+      top: r.offsetTop,
+      left: r.offsetLeft,
+      width: r.offsetWidth,
+      height: r.offsetHeight
+    };
+}
+function ze(r, e) {
+  for (var t in e)
+    if (e[t].test(r[t]))
+      return !0;
+  return !1;
+}
+var Ln = ze;
+function Fn(r, e) {
+  var t = document.createEvent("Event");
+  t.initEvent(e, !0, !0), t.pageX = r.pageX, t.pageY = r.pageY, r.target.dispatchEvent(t);
+}
+function Yr(r, e) {
+  e === void 0 && (e = "click");
+  var t;
+  r.type === "mouseup" ? t = r : (r.type === "touchend" || r.type === "touchcancel") && (t = r.changedTouches[0]);
+  var n = {};
+  t && (n.screenX = t.screenX || 0, n.screenY = t.screenY || 0, n.clientX = t.clientX || 0, n.clientY = t.clientY || 0);
+  var o, i = !0, a = !0, c = r.ctrlKey, u = r.shiftKey, l = r.altKey, f = r.metaKey, p = {
+    ctrlKey: c,
+    shiftKey: u,
+    altKey: l,
+    metaKey: f
+  };
+  if (typeof MouseEvent < "u")
+    try {
+      o = new MouseEvent(e, Bt(He({
+        bubbles: i,
+        cancelable: a
+      }, p), n));
+    } catch {
+      E();
+    }
+  else
+    E();
+  function E() {
+    o = document.createEvent("Event"), o.initEvent(e, i, a), Bt(o, n);
+  }
+  o.forwardedTouchEvent = !0, o._constructed = !0, r.target.dispatchEvent(o);
+}
+function $n(r) {
+  Yr(r, "dblclick");
+}
+var ke = {
+  // easeOutQuint
+  swipe: {
+    style: "cubic-bezier(0.23, 1, 0.32, 1)",
+    fn: function(r) {
+      return 1 + --r * r * r * r * r;
+    }
+  },
+  // easeOutQuard
+  swipeBounce: {
+    style: "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
+    fn: function(r) {
+      return r * (2 - r);
+    }
+  },
+  // easeOutQuart
+  bounce: {
+    style: "cubic-bezier(0.165, 0.84, 0.44, 1)",
+    fn: function(r) {
+      return 1 - --r * r * r * r;
+    }
+  }
+}, Xn = 1e3 / 60, ge = pe && window;
+function jr() {
+}
+var Nr = function() {
+  return pe ? ge.requestAnimationFrame || ge.webkitRequestAnimationFrame || ge.mozRequestAnimationFrame || ge.oRequestAnimationFrame || // if all else fails, use setTimeout
+  function(r) {
+    return window.setTimeout(r, r.interval || Xn);
+  } : jr;
+}(), we = function() {
+  return pe ? ge.cancelAnimationFrame || ge.webkitCancelAnimationFrame || ge.mozCancelAnimationFrame || ge.oCancelAnimationFrame || function(r) {
+    window.clearTimeout(r);
+  } : jr;
+}(), gr = function(r) {
+}, xt = {
+  enumerable: !0,
+  configurable: !0,
+  get: gr,
+  set: gr
+}, Wn = function(r, e) {
+  for (var t = e.split("."), n = 0; n < t.length - 1; n++)
+    if (r = r[t[n]], typeof r != "object" || !r)
+      return;
+  var o = t.pop();
+  return typeof r[o] == "function" ? function() {
+    return r[o].apply(r, arguments);
+  } : r[o];
+}, Hn = function(r, e, t) {
+  for (var n = e.split("."), o, i = 0; i < n.length - 1; i++)
+    o = n[i], r[o] || (r[o] = {}), r = r[o];
+  r[n.pop()] = t;
+};
+function zn(r, e, t) {
+  xt.get = function() {
+    return Wn(this, e);
+  }, xt.set = function(o) {
+    Hn(this, e, o);
+  }, Object.defineProperty(r, t, xt);
+}
+var Te = (
+  /** @class */
+  function() {
+    function r(e) {
+      this.events = {}, this.eventTypes = {}, this.registerType(e);
+    }
+    return r.prototype.on = function(e, t, n) {
+      return n === void 0 && (n = this), this.hasType(e), this.events[e] || (this.events[e] = []), this.events[e].push([t, n]), this;
+    }, r.prototype.once = function(e, t, n) {
+      var o = this;
+      n === void 0 && (n = this), this.hasType(e);
+      var i = function() {
+        for (var a = [], c = 0; c < arguments.length; c++)
+          a[c] = arguments[c];
+        o.off(e, i);
+        var u = t.apply(n, a);
+        if (u === !0)
+          return u;
+      };
+      return i.fn = t, this.on(e, i), this;
+    }, r.prototype.off = function(e, t) {
+      if (!e && !t)
+        return this.events = {}, this;
+      if (e) {
+        if (this.hasType(e), !t)
+          return this.events[e] = [], this;
+        var n = this.events[e];
+        if (!n)
+          return this;
+        for (var o = n.length; o--; )
+          (n[o][0] === t || n[o][0] && n[o][0].fn === t) && n.splice(o, 1);
+        return this;
+      }
+    }, r.prototype.trigger = function(e) {
+      for (var t = [], n = 1; n < arguments.length; n++)
+        t[n - 1] = arguments[n];
+      this.hasType(e);
+      var o = this.events[e];
+      if (o)
+        for (var i = o.length, a = Dr(o), c, u = 0; u < i; u++) {
+          var l = a[u], f = l[0], p = l[1];
+          if (f && (c = f.apply(p, t), c === !0))
+            return c;
+        }
+    }, r.prototype.registerType = function(e) {
+      var t = this;
+      e.forEach(function(n) {
+        t.eventTypes[n] = n;
+      });
+    }, r.prototype.destroy = function() {
+      this.events = {}, this.eventTypes = {};
+    }, r.prototype.hasType = function(e) {
+      var t = this.eventTypes, n = t[e] === e;
+      n || nt('EventEmitter has used unknown event type: "' + e + '", should be oneof [' + ("" + Object.keys(t).map(function(o) {
+        return JSON.stringify(o);
+      })) + "]");
+    }, r;
+  }()
+), st = (
+  /** @class */
+  function() {
+    function r(e, t) {
+      this.wrapper = e, this.events = t, this.addDOMEvents();
+    }
+    return r.prototype.destroy = function() {
+      this.removeDOMEvents(), this.events = [];
+    }, r.prototype.addDOMEvents = function() {
+      this.handleDOMEvents(In);
+    }, r.prototype.removeDOMEvents = function() {
+      this.handleDOMEvents(Bn);
+    }, r.prototype.handleDOMEvents = function(e) {
+      var t = this, n = this.wrapper;
+      this.events.forEach(function(o) {
+        e(n, o.name, t, !!o.capture);
+      });
+    }, r.prototype.handleEvent = function(e) {
+      var t = e.type;
+      this.events.some(function(n) {
+        return n.name === t ? (n.handler(e), !0) : !1;
+      });
+    }, r;
+  }()
+), Un = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function r() {
+    }
+    return r;
+  }()
+), Vn = (
+  /** @class */
+  function(r) {
+    lt(e, r);
+    function e() {
+      var t = r.call(this) || this;
+      return t.startX = 0, t.startY = 0, t.scrollX = !1, t.scrollY = !0, t.freeScroll = !1, t.directionLockThreshold = 0, t.eventPassthrough = "", t.click = !1, t.dblclick = !1, t.tap = "", t.bounce = {
+        top: !0,
+        bottom: !0,
+        left: !0,
+        right: !0
+      }, t.bounceTime = 800, t.momentum = !0, t.momentumLimitTime = 300, t.momentumLimitDistance = 15, t.swipeTime = 2500, t.swipeBounceTime = 500, t.deceleration = 15e-4, t.flickLimitTime = 200, t.flickLimitDistance = 100, t.resizePolling = 60, t.probeType = 0, t.stopPropagation = !1, t.preventDefault = !0, t.preventDefaultException = {
+        tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|AUDIO)$/
+      }, t.tagException = {
+        tagName: /^TEXTAREA$/
+      }, t.HWCompositing = !0, t.useTransition = !0, t.bindToWrapper = !1, t.bindToTarget = !1, t.disableMouse = yr, t.disableTouch = !yr, t.autoBlur = !0, t.autoEndDistance = 5, t.outOfBoundaryDampingFactor = 1 / 3, t.specifiedIndexAsContent = 0, t.quadrant = 1, t;
+    }
+    return e.prototype.merge = function(t) {
+      if (!t)
+        return this;
+      for (var n in t) {
+        if (n === "bounce") {
+          this.bounce = this.resolveBounce(t[n]);
+          continue;
+        }
+        this[n] = t[n];
+      }
+      return this;
+    }, e.prototype.process = function() {
+      return this.translateZ = this.HWCompositing && jn ? " translateZ(1px)" : "", this.useTransition = this.useTransition && Nn, 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;
+    }, e.prototype.resolveBounce = function(t) {
+      var n = {
+        top: !0,
+        right: !0,
+        bottom: !0,
+        left: !0
+      }, o = {
+        top: !1,
+        right: !1,
+        bottom: !1,
+        left: !1
+      }, i;
+      return typeof t == "object" ? i = Bt(n, t) : i = t ? n : o, i;
+    }, e;
+  }(Un)
+), qn = (
+  /** @class */
+  function() {
+    function r(e, t) {
+      this.wrapper = e, this.options = t, this.hooks = new Te([
+        "beforeStart",
+        "start",
+        "move",
+        "end",
+        "click"
+      ]), this.handleDOMEvents();
+    }
+    return r.prototype.handleDOMEvents = function() {
+      var e = this.options, t = e.bindToWrapper, n = e.disableMouse, o = e.disableTouch, i = e.click, a = this.wrapper, c = t ? a : window, u = [], l = [], f = !o, p = !n;
+      i && u.push({
+        name: "click",
+        handler: this.click.bind(this),
+        capture: !0
+      }), f && (u.push({
+        name: "touchstart",
+        handler: this.start.bind(this)
+      }), l.push({
+        name: "touchmove",
+        handler: this.move.bind(this)
+      }, {
+        name: "touchend",
+        handler: this.end.bind(this)
+      }, {
+        name: "touchcancel",
+        handler: this.end.bind(this)
+      })), p && (u.push({
+        name: "mousedown",
+        handler: this.start.bind(this)
+      }), l.push({
+        name: "mousemove",
+        handler: this.move.bind(this)
+      }, {
+        name: "mouseup",
+        handler: this.end.bind(this)
+      })), this.wrapperEventRegister = new st(a, u), this.targetEventRegister = new st(c, l);
+    }, r.prototype.beforeHandler = function(e, t) {
+      var n = this.options, o = n.preventDefault, i = n.stopPropagation, a = n.preventDefaultException, c = {
+        start: function() {
+          return o && !ze(e.target, a);
+        },
+        end: function() {
+          return o && !ze(e.target, a);
+        },
+        move: function() {
+          return o;
+        }
+      };
+      c[t]() && e.preventDefault(), i && e.stopPropagation();
+    }, r.prototype.setInitiated = function(e) {
+      e === void 0 && (e = 0), this.initiated = e;
+    }, r.prototype.start = function(e) {
+      var t = Pt[e.type];
+      if (!(this.initiated && this.initiated !== t)) {
+        if (this.setInitiated(t), Ln(e.target, this.options.tagException)) {
+          this.setInitiated();
+          return;
+        }
+        if (!(t === 2 && e.button !== 0) && !this.hooks.trigger(this.hooks.eventTypes.beforeStart, e)) {
+          this.beforeHandler(e, "start");
+          var n = e.touches ? e.touches[0] : e;
+          this.pointX = n.pageX, this.pointY = n.pageY, this.hooks.trigger(this.hooks.eventTypes.start, e);
+        }
+      }
+    }, r.prototype.move = function(e) {
+      if (Pt[e.type] === this.initiated) {
+        this.beforeHandler(e, "move");
+        var t = e.touches ? e.touches[0] : e, n = t.pageX - this.pointX, o = t.pageY - this.pointY;
+        if (this.pointX = t.pageX, this.pointY = t.pageY, !this.hooks.trigger(this.hooks.eventTypes.move, {
+          deltaX: n,
+          deltaY: o,
+          e
+        })) {
+          var i = document.documentElement.scrollLeft || window.pageXOffset || document.body.scrollLeft, a = document.documentElement.scrollTop || window.pageYOffset || document.body.scrollTop, c = this.pointX - i, u = this.pointY - a, l = this.options.autoEndDistance;
+          (c > document.documentElement.clientWidth - l || u > document.documentElement.clientHeight - l || c < l || u < l) && this.end(e);
+        }
+      }
+    }, r.prototype.end = function(e) {
+      Pt[e.type] === this.initiated && (this.setInitiated(), this.beforeHandler(e, "end"), this.hooks.trigger(this.hooks.eventTypes.end, e));
+    }, r.prototype.click = function(e) {
+      this.hooks.trigger(this.hooks.eventTypes.click, e);
+    }, r.prototype.setContent = function(e) {
+      e !== this.wrapper && (this.wrapper = e, this.rebindDOMEvents());
+    }, r.prototype.rebindDOMEvents = function() {
+      this.wrapperEventRegister.destroy(), this.targetEventRegister.destroy(), this.handleDOMEvents();
+    }, r.prototype.destroy = function() {
+      this.wrapperEventRegister.destroy(), this.targetEventRegister.destroy(), this.hooks.destroy();
+    }, r;
+  }()
+), Ct = {
+  x: ["translateX", "px"],
+  y: ["translateY", "px"]
+}, Kn = (
+  /** @class */
+  function() {
+    function r(e) {
+      this.setContent(e), this.hooks = new Te(["beforeTranslate", "translate"]);
+    }
+    return r.prototype.getComputedPosition = function() {
+      var e = window.getComputedStyle(this.content, null), t = e[xe.transform].split(")")[0].split(", "), n = +(t[12] || t[4]) || 0, o = +(t[13] || t[5]) || 0;
+      return {
+        x: n,
+        y: o
+      };
+    }, r.prototype.translate = function(e) {
+      var t = [];
+      Object.keys(e).forEach(function(n) {
+        if (Ct[n]) {
+          var o = Ct[n][0];
+          if (o) {
+            var i = Ct[n][1], a = e[n];
+            t.push(o + "(" + a + i + ")");
+          }
+        }
+      }), this.hooks.trigger(this.hooks.eventTypes.beforeTranslate, t, e), this.style[xe.transform] = t.join(" "), this.hooks.trigger(this.hooks.eventTypes.translate, e);
+    }, r.prototype.setContent = function(e) {
+      this.content !== e && (this.content = e, this.style = e.style);
+    }, r.prototype.destroy = function() {
+      this.hooks.destroy();
+    }, r;
+  }()
+), Lr = (
+  /** @class */
+  function() {
+    function r(e, t, n) {
+      this.translater = t, this.options = n, this.timer = 0, this.hooks = new Te([
+        "move",
+        "end",
+        "beforeForceStop",
+        "forceStop",
+        "callStop",
+        "time",
+        "timeFunction"
+      ]), this.setContent(e);
+    }
+    return r.prototype.translate = function(e) {
+      this.translater.translate(e);
+    }, r.prototype.setPending = function(e) {
+      this.pending = e;
+    }, r.prototype.setForceStopped = function(e) {
+      this.forceStopped = e;
+    }, r.prototype.setCallStop = function(e) {
+      this.callStopWhenPending = e;
+    }, r.prototype.setContent = function(e) {
+      this.content !== e && (this.content = e, this.style = e.style, this.stop());
+    }, r.prototype.clearTimer = function() {
+      this.timer && (we(this.timer), this.timer = 0);
+    }, r.prototype.destroy = function() {
+      this.hooks.destroy(), we(this.timer);
+    }, r;
+  }()
+), Gn = function(r, e, t, n) {
+  var o = function(l, f) {
+    var p = l - f, E = p > 0 ? -1 : p < 0 ? 1 : 0;
+    return E;
+  }, i = o(e.x, r.x), a = o(e.y, r.y), c = t.x - n.x, u = t.y - n.y;
+  return i * c <= 0 && a * u <= 0;
+}, Jn = (
+  /** @class */
+  function(r) {
+    lt(e, r);
+    function e() {
+      return r !== null && r.apply(this, arguments) || this;
+    }
+    return e.prototype.startProbe = function(t, n) {
+      var o = this, i = t, a = function() {
+        var c = o.translater.getComputedPosition();
+        Gn(t, n, c, i) && o.hooks.trigger(o.hooks.eventTypes.move, c), o.pending || (o.callStopWhenPending ? o.callStopWhenPending = !1 : o.hooks.trigger(o.hooks.eventTypes.end, c)), i = c, o.pending && (o.timer = Nr(a));
+      };
+      this.callStopWhenPending && this.setCallStop(!1), we(this.timer), a();
+    }, e.prototype.transitionTime = function(t) {
+      t === void 0 && (t = 0), this.style[xe.transitionDuration] = t + "ms", this.hooks.trigger(this.hooks.eventTypes.time, t);
+    }, e.prototype.transitionTimingFunction = function(t) {
+      this.style[xe.transitionTimingFunction] = t, this.hooks.trigger(this.hooks.eventTypes.timeFunction, t);
+    }, e.prototype.transitionProperty = function() {
+      this.style[xe.transitionProperty] = xe.transform;
+    }, e.prototype.move = function(t, n, o, i) {
+      this.setPending(o > 0), this.transitionTimingFunction(i), this.transitionProperty(), this.transitionTime(o), this.translate(n);
+      var a = this.options.probeType === 3;
+      o && a && this.startProbe(t, n), o || (this._reflow = this.content.offsetHeight, a && this.hooks.trigger(this.hooks.eventTypes.move, n), this.hooks.trigger(this.hooks.eventTypes.end, n));
+    }, e.prototype.doStop = function() {
+      var t = this.pending;
+      if (this.setForceStopped(!1), this.setCallStop(!1), t) {
+        this.setPending(!1), we(this.timer);
+        var n = this.translater.getComputedPosition(), o = n.x, i = n.y;
+        this.transitionTime(), this.translate({ x: o, y: i }), this.setForceStopped(!0), this.setCallStop(!0), this.hooks.trigger(this.hooks.eventTypes.forceStop, { x: o, y: i });
+      }
+      return t;
+    }, e.prototype.stop = function() {
+      var t = this.doStop();
+      t && this.hooks.trigger(this.hooks.eventTypes.callStop);
+    }, e;
+  }(Lr)
+), Zn = (
+  /** @class */
+  function(r) {
+    lt(e, r);
+    function e() {
+      return r !== null && r.apply(this, arguments) || this;
+    }
+    return e.prototype.move = function(t, n, o, i) {
+      if (!o) {
+        this.translate(n), this.options.probeType === 3 && this.hooks.trigger(this.hooks.eventTypes.move, n), this.hooks.trigger(this.hooks.eventTypes.end, n);
+        return;
+      }
+      this.animate(t, n, o, i);
+    }, e.prototype.animate = function(t, n, o, i) {
+      var a = this, c = Ce(), u = c + o, l = this.options.probeType === 3, f = function() {
+        var p = Ce();
+        if (p >= u) {
+          a.translate(n), l && a.hooks.trigger(a.hooks.eventTypes.move, n), a.hooks.trigger(a.hooks.eventTypes.end, n);
+          return;
+        }
+        p = (p - c) / o;
+        var E = i(p), w = {};
+        Object.keys(n).forEach(function(R) {
+          var I = t[R], Y = n[R];
+          w[R] = (Y - I) * E + I;
+        }), a.translate(w), l && a.hooks.trigger(a.hooks.eventTypes.move, w), a.pending && (a.timer = Nr(f)), a.pending || (a.callStopWhenPending ? a.callStopWhenPending = !1 : a.hooks.trigger(a.hooks.eventTypes.end, n));
+      };
+      this.setPending(!0), this.callStopWhenPending && this.setCallStop(!1), we(this.timer), f();
+    }, e.prototype.doStop = function() {
+      var t = this.pending;
+      if (this.setForceStopped(!1), this.setCallStop(!1), t) {
+        this.setPending(!1), we(this.timer);
+        var n = this.translater.getComputedPosition();
+        this.setForceStopped(!0), this.setCallStop(!0), this.hooks.trigger(this.hooks.eventTypes.forceStop, n);
+      }
+      return t;
+    }, e.prototype.stop = function() {
+      var t = this.doStop();
+      t && this.hooks.trigger(this.hooks.eventTypes.callStop);
+    }, e;
+  }(Lr)
+);
+function Qn(r, e, t) {
+  var n = t.useTransition, o = {};
+  return Object.defineProperty(o, "probeType", {
+    enumerable: !0,
+    configurable: !1,
+    get: function() {
+      return t.probeType;
+    }
+  }), n ? new Jn(r, e, o) : new Zn(r, e, o);
+}
+var Tr = (
+  /** @class */
+  function() {
+    function r(e, t, n) {
+      this.wrapper = e, this.options = n, this.hooks = new Te([
+        "beforeComputeBoundary",
+        "computeBoundary",
+        "momentum",
+        "end",
+        "ignoreHasScroll"
+      ]), this.refresh(t);
+    }
+    return r.prototype.start = function() {
+      this.dist = 0, this.setMovingDirection(
+        0
+        /* Default */
+      ), this.setDirection(
+        0
+        /* Default */
+      );
+    }, r.prototype.move = function(e) {
+      return e = this.hasScroll ? e : 0, this.setMovingDirection(e), this.performDampingAlgorithm(e, this.options.outOfBoundaryDampingFactor);
+    }, r.prototype.setMovingDirection = function(e) {
+      this.movingDirection = e > 0 ? -1 : e < 0 ? 1 : 0;
+    }, r.prototype.setDirection = function(e) {
+      this.direction = e > 0 ? -1 : e < 0 ? 1 : 0;
+    }, r.prototype.performDampingAlgorithm = function(e, t) {
+      var n = this.currentPos + e;
+      return (n > this.minScrollPos || n < this.maxScrollPos) && (n > this.minScrollPos && this.options.bounces[0] || n < this.maxScrollPos && this.options.bounces[1] ? n = this.currentPos + e * t : n = n > this.minScrollPos ? this.minScrollPos : this.maxScrollPos), n;
+    }, r.prototype.end = function(e) {
+      var t = {
+        duration: 0
+      }, n = Math.abs(this.currentPos - this.startPos);
+      if (this.options.momentum && e < this.options.momentumLimitTime && n > this.options.momentumLimitDistance) {
+        var o = this.direction === -1 && this.options.bounces[0] || this.direction === 1 && this.options.bounces[1] ? this.wrapperSize : 0;
+        t = this.hasScroll ? this.momentum(this.currentPos, this.startPos, e, this.maxScrollPos, this.minScrollPos, o, this.options) : { destination: this.currentPos, duration: 0 };
+      } else
+        this.hooks.trigger(this.hooks.eventTypes.end, t);
+      return t;
+    }, r.prototype.momentum = function(e, t, n, o, i, a, c) {
+      c === void 0 && (c = this.options);
+      var u = e - t, l = Math.abs(u) / n, f = c.deceleration, p = c.swipeBounceTime, E = c.swipeTime, w = Math.min(E, l * 2 / f), R = {
+        destination: e + l * l / f * (u < 0 ? -1 : 1),
+        duration: w,
+        rate: 15
+      };
+      return this.hooks.trigger(this.hooks.eventTypes.momentum, R, u), R.destination < o ? (R.destination = a ? Math.max(o - a / 4, o - a / R.rate * l) : o, R.duration = p) : R.destination > i && (R.destination = a ? Math.min(i + a / 4, i + a / R.rate * l) : i, R.duration = p), R.destination = Math.round(R.destination), R;
+    }, r.prototype.updateDirection = function() {
+      var e = this.currentPos - this.absStartPos;
+      this.setDirection(e);
+    }, r.prototype.refresh = function(e) {
+      var t = this.options.rect, n = t.size, o = t.position, i = window.getComputedStyle(this.wrapper, null).position === "static", a = mr(this.wrapper);
+      this.wrapperSize = this.wrapper[n === "width" ? "clientWidth" : "clientHeight"], this.setContent(e);
+      var c = mr(this.content);
+      this.contentSize = c[n], this.relativeOffset = c[o], i && (this.relativeOffset -= a[o]), this.computeBoundary(), this.setDirection(
+        0
+        /* Default */
+      );
+    }, r.prototype.setContent = function(e) {
+      e !== this.content && (this.content = e, this.resetState());
+    }, r.prototype.resetState = function() {
+      this.currentPos = 0, this.startPos = 0, this.dist = 0, this.setDirection(
+        0
+        /* Default */
+      ), this.setMovingDirection(
+        0
+        /* Default */
+      ), this.resetStartPos();
+    }, r.prototype.computeBoundary = function() {
+      this.hooks.trigger(this.hooks.eventTypes.beforeComputeBoundary);
+      var e = {
+        minScrollPos: 0,
+        maxScrollPos: this.wrapperSize - this.contentSize
+      };
+      e.maxScrollPos < 0 && (e.maxScrollPos -= this.relativeOffset, this.options.specifiedIndexAsContent === 0 && (e.minScrollPos = -this.relativeOffset)), this.hooks.trigger(this.hooks.eventTypes.computeBoundary, e), this.minScrollPos = e.minScrollPos, this.maxScrollPos = e.maxScrollPos, this.hasScroll = this.options.scrollable && this.maxScrollPos < this.minScrollPos, !this.hasScroll && this.minScrollPos < this.maxScrollPos && (this.maxScrollPos = this.minScrollPos, this.contentSize = this.wrapperSize);
+    }, r.prototype.updatePosition = function(e) {
+      this.currentPos = e;
+    }, r.prototype.getCurrentPos = function() {
+      return this.currentPos;
+    }, r.prototype.checkInBoundary = function() {
+      var e = this.adjustPosition(this.currentPos), t = e === this.getCurrentPos();
+      return {
+        position: e,
+        inBoundary: t
+      };
+    }, r.prototype.adjustPosition = function(e) {
+      return !this.hasScroll && !this.hooks.trigger(this.hooks.eventTypes.ignoreHasScroll) ? e = this.minScrollPos : e > this.minScrollPos ? e = this.minScrollPos : e < this.maxScrollPos && (e = this.maxScrollPos), e;
+    }, r.prototype.updateStartPos = function() {
+      this.startPos = this.currentPos;
+    }, r.prototype.updateAbsStartPos = function() {
+      this.absStartPos = this.currentPos;
+    }, r.prototype.resetStartPos = function() {
+      this.updateStartPos(), this.updateAbsStartPos();
+    }, r.prototype.getAbsDist = function(e) {
+      return this.dist += e, Math.abs(this.dist);
+    }, r.prototype.destroy = function() {
+      this.hooks.destroy();
+    }, r;
+  }()
+), Ze, Qe, et, tt, Er = (Ze = {}, Ze.yes = function(r) {
+  return !0;
+}, Ze.no = function(r) {
+  return Ir(r), !1;
+}, Ze), eo = (Qe = {}, Qe.horizontal = (et = {}, et.yes = "horizontal", et.no = "vertical", et), Qe.vertical = (tt = {}, tt.yes = "vertical", tt.no = "horizontal", tt), Qe), to = (
+  /** @class */
+  function() {
+    function r(e, t, n) {
+      this.directionLockThreshold = e, this.freeScroll = t, this.eventPassthrough = n, this.reset();
+    }
+    return r.prototype.reset = function() {
+      this.directionLocked = "";
+    }, r.prototype.checkMovingDirection = function(e, t, n) {
+      return this.computeDirectionLock(e, t), this.handleEventPassthrough(n);
+    }, r.prototype.adjustDelta = function(e, t) {
+      return this.directionLocked === "horizontal" ? t = 0 : this.directionLocked === "vertical" && (e = 0), {
+        deltaX: e,
+        deltaY: t
+      };
+    }, r.prototype.computeDirectionLock = function(e, t) {
+      this.directionLocked === "" && !this.freeScroll && (e > t + this.directionLockThreshold ? this.directionLocked = "horizontal" : t >= e + this.directionLockThreshold ? this.directionLocked = "vertical" : this.directionLocked = "none");
+    }, r.prototype.handleEventPassthrough = function(e) {
+      var t = eo[this.directionLocked];
+      if (t) {
+        if (this.eventPassthrough === t.yes)
+          return Er.yes(e);
+        if (this.eventPassthrough === t.no)
+          return Er.no(e);
+      }
+      return !1;
+    }, r;
+  }()
+), ro = function(r, e, t) {
+  return t === 2 ? [e, -r] : t === 3 ? [-r, -e] : t === 4 ? [-e, r] : [r, e];
+}, no = (
+  /** @class */
+  function() {
+    function r(e, t, n, o, i) {
+      this.hooks = new Te([
+        "start",
+        "beforeMove",
+        "scrollStart",
+        "scroll",
+        "beforeEnd",
+        "end",
+        "scrollEnd",
+        "contentNotMoved",
+        "detectMovingDirection",
+        "coordinateTransformation"
+      ]), this.scrollBehaviorX = e, this.scrollBehaviorY = t, this.actionsHandler = n, this.animater = o, this.options = i, this.directionLockAction = new to(i.directionLockThreshold, i.freeScroll, i.eventPassthrough), this.enabled = !0, this.bindActionsHandler();
+    }
+    return r.prototype.bindActionsHandler = function() {
+      var e = this;
+      this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.start, function(t) {
+        return e.enabled ? e.handleStart(t) : !0;
+      }), this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.move, function(t) {
+        var n = t.deltaX, o = t.deltaY, i = t.e;
+        if (!e.enabled)
+          return !0;
+        var a = ro(n, o, e.options.quadrant), c = a[0], u = a[1], l = {
+          deltaX: c,
+          deltaY: u
+        };
+        return e.hooks.trigger(e.hooks.eventTypes.coordinateTransformation, l), e.handleMove(l.deltaX, l.deltaY, i);
+      }), this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.end, function(t) {
+        return e.enabled ? e.handleEnd(t) : !0;
+      }), this.actionsHandler.hooks.on(this.actionsHandler.hooks.eventTypes.click, function(t) {
+        e.enabled && !t._constructed && e.handleClick(t);
+      });
+    }, r.prototype.handleStart = function(e) {
+      var t = Ce();
+      this.fingerMoved = !1, this.contentMoved = !1, this.startTime = t, 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, e);
+    }, r.prototype.handleMove = function(e, t, n) {
+      if (!this.hooks.trigger(this.hooks.eventTypes.beforeMove, n)) {
+        var o = this.scrollBehaviorX.getAbsDist(e), i = this.scrollBehaviorY.getAbsDist(t), a = Ce();
+        if (this.checkMomentum(o, i, a))
+          return !0;
+        if (this.directionLockAction.checkMovingDirection(o, i, n))
+          return this.actionsHandler.setInitiated(), !0;
+        var c = this.directionLockAction.adjustDelta(e, t), u = this.scrollBehaviorX.getCurrentPos(), l = this.scrollBehaviorX.move(c.deltaX), f = this.scrollBehaviorY.getCurrentPos(), p = this.scrollBehaviorY.move(c.deltaY);
+        if (!this.hooks.trigger(this.hooks.eventTypes.detectMovingDirection)) {
+          this.fingerMoved || (this.fingerMoved = !0);
+          var E = l !== u || p !== f;
+          !this.contentMoved && !E && this.hooks.trigger(this.hooks.eventTypes.contentNotMoved), !this.contentMoved && E && (this.contentMoved = !0, this.hooks.trigger(this.hooks.eventTypes.scrollStart)), this.contentMoved && E && (this.animater.translate({
+            x: l,
+            y: p
+          }), this.dispatchScroll(a));
+        }
+      }
+    }, r.prototype.dispatchScroll = function(e) {
+      e - this.startTime > this.options.momentumLimitTime && (this.startTime = e, 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());
+    }, r.prototype.checkMomentum = function(e, t, n) {
+      return n - this.endTime > this.options.momentumLimitTime && t < this.options.momentumLimitDistance && e < this.options.momentumLimitDistance;
+    }, r.prototype.handleEnd = function(e) {
+      if (!this.hooks.trigger(this.hooks.eventTypes.beforeEnd, e)) {
+        var t = this.getCurrentPos();
+        if (this.scrollBehaviorX.updateDirection(), this.scrollBehaviorY.updateDirection(), this.hooks.trigger(this.hooks.eventTypes.end, e, t))
+          return !0;
+        t = this.ensureIntegerPos(t), this.animater.translate(t), this.endTime = Ce();
+        var n = this.endTime - this.startTime;
+        this.hooks.trigger(this.hooks.eventTypes.scrollEnd, t, n);
+      }
+    }, r.prototype.ensureIntegerPos = function(e) {
+      this.ensuringInteger = !0;
+      var t = e.x, n = e.y, o = this.scrollBehaviorX, i = o.minScrollPos, a = o.maxScrollPos, c = this.scrollBehaviorY, u = c.minScrollPos, l = c.maxScrollPos;
+      return t = t > 0 ? Math.ceil(t) : Math.floor(t), n = n > 0 ? Math.ceil(n) : Math.floor(n), t = dr(t, a, i), n = dr(n, l, u), { x: t, y: n };
+    }, r.prototype.handleClick = function(e) {
+      ze(e.target, this.options.preventDefaultException) || (Ir(e), e.stopPropagation());
+    }, r.prototype.getCurrentPos = function() {
+      return {
+        x: this.scrollBehaviorX.getCurrentPos(),
+        y: this.scrollBehaviorY.getCurrentPos()
+      };
+    }, r.prototype.refresh = function() {
+      this.endTime = 0;
+    }, r.prototype.destroy = function() {
+      this.hooks.destroy();
+    }, r;
+  }()
+);
+function oo(r) {
+  var e = [
+    "click",
+    "bindToWrapper",
+    "disableMouse",
+    "disableTouch",
+    "preventDefault",
+    "stopPropagation",
+    "tagException",
+    "preventDefaultException",
+    "autoEndDistance"
+  ].reduce(function(t, n) {
+    return t[n] = r[n], t;
+  }, {});
+  return e;
+}
+function br(r, e, t, n) {
+  var o = [
+    "momentum",
+    "momentumLimitTime",
+    "momentumLimitDistance",
+    "deceleration",
+    "swipeBounceTime",
+    "swipeTime",
+    "outOfBoundaryDampingFactor",
+    "specifiedIndexAsContent"
+  ].reduce(function(i, a) {
+    return i[a] = r[a], i;
+  }, {});
+  return o.scrollable = !!r[e], o.bounces = t, o.rect = n, o;
+}
+function jt(r, e, t) {
+  t.forEach(function(n) {
+    var o, i;
+    typeof n == "string" ? o = i = n : (o = n.source, i = n.target), r.on(o, function() {
+      for (var a = [], c = 0; c < arguments.length; c++)
+        a[c] = arguments[c];
+      return e.trigger.apply(e, Dr([i], a));
+    });
+  });
+}
+function io(r, e) {
+  for (var t = Object.keys(r), n = 0, o = t; n < o.length; n++) {
+    var i = o[n];
+    if (r[i] !== e[i])
+      return !1;
+  }
+  return !0;
+}
+var kr = 1, so = (
+  /** @class */
+  function() {
+    function r(e, t, n) {
+      this.wrapper = e, this.content = t, this.resizeTimeout = 0, this.hooks = new Te([
+        "beforeStart",
+        "beforeMove",
+        "beforeScrollStart",
+        "scrollStart",
+        "scroll",
+        "beforeEnd",
+        "scrollEnd",
+        "resize",
+        "touchEnd",
+        "end",
+        "flick",
+        "scrollCancel",
+        "momentum",
+        "scrollTo",
+        "minDistanceScroll",
+        "scrollToElement",
+        "beforeRefresh"
+      ]), this.options = n;
+      var o = this.options.bounce, i = o.left, a = o.right, c = o.top, u = o.bottom;
+      this.scrollBehaviorX = new Tr(e, t, br(n, "scrollX", [i, a], {
+        size: "width",
+        position: "left"
+      })), this.scrollBehaviorY = new Tr(e, t, br(n, "scrollY", [c, u], {
+        size: "height",
+        position: "top"
+      })), this.translater = new Kn(this.content), this.animater = Qn(this.content, this.translater, this.options), this.actionsHandler = new qn(this.options.bindToTarget ? this.content : e, oo(this.options)), this.actions = new no(this.scrollBehaviorX, this.scrollBehaviorY, this.actionsHandler, this.animater, this.options);
+      var l = this.resize.bind(this);
+      this.resizeRegister = new st(window, [
+        {
+          name: "orientationchange",
+          handler: l
+        },
+        {
+          name: "resize",
+          handler: l
+        }
+      ]), this.registerTransitionEnd(), this.init();
+    }
+    return r.prototype.init = function() {
+      var e = this;
+      this.bindTranslater(), this.bindAnimater(), this.bindActions(), this.hooks.on(this.hooks.eventTypes.scrollEnd, function() {
+        e.togglePointerEvents(!0);
+      });
+    }, r.prototype.registerTransitionEnd = function() {
+      this.transitionEndRegister = new st(this.content, [
+        {
+          name: xe.transitionEnd,
+          handler: this.transitionEnd.bind(this)
+        }
+      ]);
+    }, r.prototype.bindTranslater = function() {
+      var e = this, t = this.translater.hooks;
+      t.on(t.eventTypes.beforeTranslate, function(n) {
+        e.options.translateZ && n.push(e.options.translateZ);
+      }), t.on(t.eventTypes.translate, function(n) {
+        var o = e.getCurrentPos();
+        if (e.updatePositions(n), e.actions.ensuringInteger === !0) {
+          e.actions.ensuringInteger = !1;
+          return;
+        }
+        (n.x !== o.x || n.y !== o.y) && e.togglePointerEvents(!1);
+      });
+    }, r.prototype.bindAnimater = function() {
+      var e = this;
+      this.animater.hooks.on(this.animater.hooks.eventTypes.end, function(t) {
+        e.resetPosition(e.options.bounceTime) || (e.animater.setPending(!1), e.hooks.trigger(e.hooks.eventTypes.scrollEnd, t));
+      }), jt(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
+        }
+      ]);
+    }, r.prototype.bindActions = function() {
+      var e = this, t = this.actions;
+      jt(t.hooks, this.hooks, [
+        {
+          source: t.hooks.eventTypes.start,
+          target: this.hooks.eventTypes.beforeStart
+        },
+        {
+          source: t.hooks.eventTypes.start,
+          target: this.hooks.eventTypes.beforeScrollStart
+        },
+        {
+          source: t.hooks.eventTypes.beforeMove,
+          target: this.hooks.eventTypes.beforeMove
+        },
+        {
+          source: t.hooks.eventTypes.scrollStart,
+          target: this.hooks.eventTypes.scrollStart
+        },
+        {
+          source: t.hooks.eventTypes.scroll,
+          target: this.hooks.eventTypes.scroll
+        },
+        {
+          source: t.hooks.eventTypes.beforeEnd,
+          target: this.hooks.eventTypes.beforeEnd
+        }
+      ]), t.hooks.on(t.hooks.eventTypes.end, function(n, o) {
+        if (e.hooks.trigger(e.hooks.eventTypes.touchEnd, o), e.hooks.trigger(e.hooks.eventTypes.end, o) || !t.fingerMoved && (e.hooks.trigger(e.hooks.eventTypes.scrollCancel), e.checkClick(n)))
+          return !0;
+        if (e.resetPosition(e.options.bounceTime, ke.bounce))
+          return e.animater.setForceStopped(!1), !0;
+      }), t.hooks.on(t.hooks.eventTypes.scrollEnd, function(n, o) {
+        var i = Math.abs(n.x - e.scrollBehaviorX.startPos), a = Math.abs(n.y - e.scrollBehaviorY.startPos);
+        if (e.checkFlick(o, i, a)) {
+          e.animater.setForceStopped(!1), e.hooks.trigger(e.hooks.eventTypes.flick);
+          return;
+        }
+        if (e.momentum(n, o)) {
+          e.animater.setForceStopped(!1);
+          return;
+        }
+        t.contentMoved && e.hooks.trigger(e.hooks.eventTypes.scrollEnd, n), e.animater.forceStopped && e.animater.setForceStopped(!1);
+      });
+    }, r.prototype.checkFlick = function(e, t, n) {
+      var o = 1;
+      if (this.hooks.events.flick.length > 1 && e < this.options.flickLimitTime && t < this.options.flickLimitDistance && n < this.options.flickLimitDistance && (n > o || t > o))
+        return !0;
+    }, r.prototype.momentum = function(e, t) {
+      var n = {
+        time: 0,
+        easing: ke.swiper,
+        newX: e.x,
+        newY: e.y
+      }, o = this.scrollBehaviorX.end(t), i = this.scrollBehaviorY.end(t);
+      if (n.newX = Yt(o.destination) ? n.newX : o.destination, n.newY = Yt(i.destination) ? n.newY : i.destination, n.time = Math.max(o.duration, i.duration), this.hooks.trigger(this.hooks.eventTypes.momentum, n, this), n.newX !== e.x || n.newY !== e.y)
+        return (n.newX > this.scrollBehaviorX.minScrollPos || n.newX < this.scrollBehaviorX.maxScrollPos || n.newY > this.scrollBehaviorY.minScrollPos || n.newY < this.scrollBehaviorY.maxScrollPos) && (n.easing = ke.swipeBounce), this.scrollTo(n.newX, n.newY, n.time, n.easing), !0;
+    }, r.prototype.checkClick = function(e) {
+      var t = {
+        preventClick: this.animater.forceStopped
+      };
+      if (this.hooks.trigger(this.hooks.eventTypes.checkClick))
+        return this.animater.setForceStopped(!1), !0;
+      if (!t.preventClick) {
+        var n = this.options.dblclick, o = !1;
+        if (n && this.lastClickTime) {
+          var i = n.delay, a = i === void 0 ? 300 : i;
+          Ce() - this.lastClickTime < a && (o = !0, $n(e));
+        }
+        return this.options.tap && Fn(e, this.options.tap), this.options.click && !ze(e.target, this.options.preventDefaultException) && Yr(e), this.lastClickTime = o ? null : Ce(), !0;
+      }
+      return !1;
+    }, r.prototype.resize = function() {
+      var e = this;
+      this.actions.enabled && (Dn && (this.wrapper.scrollTop = 0), clearTimeout(this.resizeTimeout), this.resizeTimeout = window.setTimeout(function() {
+        e.hooks.trigger(e.hooks.eventTypes.resize);
+      }, this.options.resizePolling));
+    }, r.prototype.transitionEnd = function(e) {
+      if (!(e.target !== this.content || !this.animater.pending)) {
+        var t = this.animater;
+        t.transitionTime(), this.resetPosition(this.options.bounceTime, ke.bounce) || (this.animater.setPending(!1), this.options.probeType !== 3 && this.hooks.trigger(this.hooks.eventTypes.scrollEnd, this.getCurrentPos()));
+      }
+    }, r.prototype.togglePointerEvents = function(e) {
+      e === void 0 && (e = !0);
+      for (var t = this.content.children.length ? this.content.children : [this.content], n = e ? "auto" : "none", o = 0; o < t.length; o++) {
+        var i = t[o];
+        i.isBScrollContainer || (i.style.pointerEvents = n);
+      }
+    }, r.prototype.refresh = function(e) {
+      var t = this.setContent(e);
+      this.hooks.trigger(this.hooks.eventTypes.beforeRefresh), this.scrollBehaviorX.refresh(e), this.scrollBehaviorY.refresh(e), t && (this.translater.setContent(e), this.animater.setContent(e), this.transitionEndRegister.destroy(), this.registerTransitionEnd(), this.options.bindToTarget && this.actionsHandler.setContent(e)), this.actions.refresh(), this.wrapperOffset = vr(this.wrapper);
+    }, r.prototype.setContent = function(e) {
+      var t = e !== this.content;
+      return t && (this.content = e), t;
+    }, r.prototype.scrollBy = function(e, t, n, o) {
+      n === void 0 && (n = 0);
+      var i = this.getCurrentPos(), a = i.x, c = i.y;
+      o = o || ke.bounce, e += a, t += c, this.scrollTo(e, t, n, o);
+    }, r.prototype.scrollTo = function(e, t, n, o, i) {
+      n === void 0 && (n = 0), o === void 0 && (o = ke.bounce), i === void 0 && (i = {
+        start: {},
+        end: {}
+      });
+      var a = this.options.useTransition ? o.style : o.fn, c = this.getCurrentPos(), u = He({ x: c.x, y: c.y }, i.start), l = He({
+        x: e,
+        y: t
+      }, i.end);
+      if (this.hooks.trigger(this.hooks.eventTypes.scrollTo, l), !io(u, l)) {
+        var f = Math.abs(l.x - u.x), p = Math.abs(l.y - u.y);
+        f < kr && p < kr && (n = 0, this.hooks.trigger(this.hooks.eventTypes.minDistanceScroll)), this.animater.move(u, l, n, a);
+      }
+    }, r.prototype.scrollToElement = function(e, t, n, o, i) {
+      var a = Mr(e), c = vr(a), u = function(f, p, E) {
+        return typeof f == "number" ? f : f ? Math.round(p / 2 - E / 2) : 0;
+      };
+      n = u(n, a.offsetWidth, this.wrapper.offsetWidth), o = u(o, a.offsetHeight, this.wrapper.offsetHeight);
+      var l = function(f, p, E, w) {
+        return f -= p, f = w.adjustPosition(f - E), f;
+      };
+      c.left = l(c.left, this.wrapperOffset.left, n, this.scrollBehaviorX), c.top = l(c.top, this.wrapperOffset.top, o, this.scrollBehaviorY), !this.hooks.trigger(this.hooks.eventTypes.scrollToElement, a, c) && this.scrollTo(c.left, c.top, t, i);
+    }, r.prototype.resetPosition = function(e, t) {
+      e === void 0 && (e = 0), t === void 0 && (t = ke.bounce);
+      var n = this.scrollBehaviorX.checkInBoundary(), o = n.position, i = n.inBoundary, a = this.scrollBehaviorY.checkInBoundary(), c = a.position, u = a.inBoundary;
+      return i && u ? !1 : (An && this.reflow(), this.scrollTo(o, c, e, t), !0);
+    }, r.prototype.reflow = function() {
+      this._reflow = this.content.offsetHeight;
+    }, r.prototype.updatePositions = function(e) {
+      this.scrollBehaviorX.updatePosition(e.x), this.scrollBehaviorY.updatePosition(e.y);
+    }, r.prototype.getCurrentPos = function() {
+      return this.actions.getCurrentPos();
+    }, r.prototype.enable = function() {
+      this.actions.enabled = !0;
+    }, r.prototype.disable = function() {
+      we(this.animater.timer), this.actions.enabled = !1;
+    }, r.prototype.destroy = function() {
+      var e = this, t = [
+        "resizeRegister",
+        "transitionEndRegister",
+        "actionsHandler",
+        "actions",
+        "hooks",
+        "animater",
+        "translater",
+        "scrollBehaviorX",
+        "scrollBehaviorY"
+      ];
+      t.forEach(function(n) {
+        return e[n].destroy();
+      });
+    }, r;
+  }()
+), ut = (
+  /** @class */
+  function(r) {
+    lt(e, r);
+    function e(t, n) {
+      var o = r.call(this, [
+        "refresh",
+        "contentChanged",
+        "enable",
+        "disable",
+        "beforeScrollStart",
+        "scrollStart",
+        "scroll",
+        "scrollEnd",
+        "scrollCancel",
+        "touchEnd",
+        "flick",
+        "destroy"
+      ]) || this, i = Mr(t);
+      return i ? (o.plugins = {}, o.options = new Vn().merge(n).process(), o.setContent(i).valid && (o.hooks = new Te([
+        "refresh",
+        "enable",
+        "disable",
+        "destroy",
+        "beforeInitialScrollTo",
+        "contentChanged"
+      ]), o.init(i)), o) : (nt("Can not resolve the wrapper DOM."), o);
+    }
+    return e.use = function(t) {
+      var n = t.pluginName, o = e.plugins.some(function(i) {
+        return t === i.ctor;
+      });
+      return o ? e : Yt(n) ? (nt("Plugin Class must specify plugin's name in static property by 'pluginName' field."), e) : (e.pluginsMap[n] = !0, e.plugins.push({
+        name: n,
+        applyOrder: t.applyOrder,
+        ctor: t
+      }), e);
+    }, e.prototype.setContent = function(t) {
+      var n = !1, o = !0, i = t.children[this.options.specifiedIndexAsContent];
+      return i ? (n = this.content !== i, n && (this.content = i)) : (nt("The wrapper need at least one child element to be content element to scroll."), o = !1), {
+        valid: o,
+        contentChanged: n
+      };
+    }, e.prototype.init = function(t) {
+      var n = this;
+      this.wrapper = t, t.isBScrollContainer = !0, this.scroller = new so(t, this.content, this.options), this.scroller.hooks.on(this.scroller.hooks.eventTypes.resize, function() {
+        n.refresh();
+      }), this.eventBubbling(), this.handleAutoBlur(), this.enable(), this.proxy(_n), this.applyPlugins(), this.refreshWithoutReset(this.content);
+      var o = this.options, i = o.startX, a = o.startY, c = {
+        x: i,
+        y: a
+      };
+      this.hooks.trigger(this.hooks.eventTypes.beforeInitialScrollTo, c) || this.scroller.scrollTo(c.x, c.y);
+    }, e.prototype.applyPlugins = function() {
+      var t = this, n = this.options;
+      e.plugins.sort(function(o, i) {
+        var a, c = (a = {}, a.pre = -1, a.post = 1, a), u = o.applyOrder ? c[o.applyOrder] : 0, l = i.applyOrder ? c[i.applyOrder] : 0;
+        return u - l;
+      }).forEach(function(o) {
+        var i = o.ctor;
+        n[o.name] && typeof i == "function" && (t.plugins[o.name] = new i(t));
+      });
+    }, e.prototype.handleAutoBlur = function() {
+      this.options.autoBlur && this.on(this.eventTypes.beforeScrollStart, function() {
+        var t = document.activeElement;
+        t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA") && t.blur();
+      });
+    }, e.prototype.eventBubbling = function() {
+      jt(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
+      ]);
+    }, e.prototype.refreshWithoutReset = function(t) {
+      this.scroller.refresh(t), this.hooks.trigger(this.hooks.eventTypes.refresh, t), this.trigger(this.eventTypes.refresh, t);
+    }, e.prototype.proxy = function(t) {
+      var n = this;
+      t.forEach(function(o) {
+        var i = o.key, a = o.sourceKey;
+        zn(n, a, i);
+      });
+    }, e.prototype.refresh = function() {
+      var t = this.setContent(this.wrapper), n = t.contentChanged, o = t.valid;
+      if (o) {
+        var i = this.content;
+        this.refreshWithoutReset(i), n && (this.hooks.trigger(this.hooks.eventTypes.contentChanged, i), this.trigger(this.eventTypes.contentChanged, i)), this.scroller.resetPosition();
+      }
+    }, e.prototype.enable = function() {
+      this.scroller.enable(), this.hooks.trigger(this.hooks.eventTypes.enable), this.trigger(this.eventTypes.enable);
+    }, e.prototype.disable = function() {
+      this.scroller.disable(), this.hooks.trigger(this.hooks.eventTypes.disable), this.trigger(this.eventTypes.disable);
+    }, e.prototype.destroy = function() {
+      this.hooks.trigger(this.hooks.eventTypes.destroy), this.trigger(this.eventTypes.destroy), this.scroller.destroy();
+    }, e.prototype.eventRegister = function(t) {
+      this.registerType(t);
+    }, e.plugins = [], e.pluginsMap = {}, e;
+  }(Te)
+);
+function Ue(r, e) {
+  var t = new ut(r, e);
+  return t;
+}
+Ue.use = ut.use;
+Ue.plugins = ut.plugins;
+Ue.pluginsMap = ut.pluginsMap;
+var ao = Ue;
+/*!
+ * better-scroll / wheel
+ * (c) 2016-2023 ustbhuangyi
+ * Released under the MIT License.
+ */
+var Ve = typeof window < "u", at = Ve && navigator.userAgent.toLowerCase();
+at && at.indexOf("android") > 0;
+(function() {
+  if (typeof at == "string") {
+    var r = /os (\d\d?_\d(_\d)?)/, e = r.exec(at);
+    if (!e)
+      return !1;
+    var t = e[1].split("_").map(function(n) {
+      return parseInt(n, 10);
+    });
+    return t[0] === 13 && t[1] >= 4;
+  }
+  return !1;
+})();
+var co = !1;
+if (Ve) {
+  var lo = "test-passive";
+  try {
+    var Sr = {};
+    Object.defineProperty(Sr, "passive", {
+      get: function() {
+        co = !0;
+      }
+    }), window.addEventListener(lo, function() {
+    }, Sr);
+  } catch {
+  }
+}
+var uo = function(r, e) {
+  for (var t in e)
+    r[t] = e[t];
+  return r;
+}, Fr = Ve && document.createElement("div").style, Be = function() {
+  if (!Ve)
+    return !1;
+  for (var r = [
+    {
+      key: "standard",
+      value: "transform"
+    },
+    {
+      key: "webkit",
+      value: "webkitTransform"
+    },
+    {
+      key: "Moz",
+      value: "MozTransform"
+    },
+    {
+      key: "O",
+      value: "OTransform"
+    },
+    {
+      key: "ms",
+      value: "msTransform"
+    }
+  ], e = 0, t = r; e < t.length; e++) {
+    var n = t[e];
+    if (Fr[n.value] !== void 0)
+      return n.key;
+  }
+  return !1;
+}();
+function ye(r) {
+  return Be === !1 ? r : Be === "standard" ? r === "transitionEnd" ? "transitionend" : r : Be + r.charAt(0).toUpperCase() + r.substr(1);
+}
+Be && Be !== "standard" && "" + Be.toLowerCase();
+var fo = ye("transform"), ho = ye("transition");
+Ve && ye("perspective") in Fr;
+var wt = {
+  transform: fo,
+  transition: ho,
+  transitionTimingFunction: ye("transitionTimingFunction"),
+  transitionDuration: ye("transitionDuration"),
+  transitionDelay: ye("transitionDelay"),
+  transformOrigin: ye("transformOrigin"),
+  transitionEnd: ye("transitionEnd"),
+  transitionProperty: ye("transitionProperty")
+};
+function rt(r, e) {
+  var t = new RegExp("(^|\\s)" + e + "(\\s|$)");
+  return t.test(r.className);
+}
+function po(r) {
+  return Array.prototype.slice.call(r, 0);
+}
+var vo = {
+  // easeOutQuint
+  swipe: {
+    style: "cubic-bezier(0.23, 1, 0.32, 1)",
+    fn: function(r) {
+      return 1 + --r * r * r * r * r;
+    }
+  },
+  // easeOutQuard
+  swipeBounce: {
+    style: "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
+    fn: function(r) {
+      return r * (2 - r);
+    }
+  },
+  // easeOutQuart
+  bounce: {
+    style: "cubic-bezier(0.165, 0.84, 0.44, 1)",
+    fn: function(r) {
+      return 1 - --r * r * r * r;
+    }
+  }
+}, yo = "plugins.wheel", mo = [
+  {
+    key: "wheelTo",
+    name: "wheelTo"
+  },
+  {
+    key: "getSelectedIndex",
+    name: "getSelectedIndex"
+  },
+  {
+    key: "restorePosition",
+    name: "restorePosition"
+  }
+], go = mo.map(function(r) {
+  return {
+    key: r.key,
+    sourceKey: yo + "." + r.name
+  };
+}), Pr = "wheelIndexChanged", To = {
+  rate: 4
+}, Eo = (
+  /** @class */
+  function() {
+    function r(e) {
+      this.scroll = e, this.init();
+    }
+    return r.prototype.init = function() {
+      this.handleBScroll(), this.handleOptions(), this.handleHooks(), this.refreshBoundary(), this.setSelectedIndex(this.options.selectedIndex);
+    }, r.prototype.handleBScroll = function() {
+      this.scroll.proxy(go), this.scroll.registerType([Pr]);
+    }, r.prototype.handleOptions = function() {
+      var e = this.scroll.options.wheel === !0 ? {} : this.scroll.options.wheel, t = {
+        wheelWrapperClass: "wheel-scroll",
+        wheelItemClass: "wheel-item",
+        rotate: 25,
+        adjustTime: 400,
+        selectedIndex: 0,
+        wheelDisabledItemClass: "wheel-disabled-item"
+      };
+      this.options = uo(t, e);
+    }, r.prototype.handleHooks = function() {
+      var e = this, t = this.scroll, n = this.scroll.scroller, o = n.actionsHandler, i = n.scrollBehaviorX, a = n.scrollBehaviorY, c = n.animater, u = n.content;
+      t.on(t.eventTypes.scrollEnd, function(l) {
+        var f = e.findNearestValidWheel(l.y).index;
+        if (n.animater.forceStopped && !e.isAdjustingPosition)
+          return e.target = e.items[f], !0;
+        e.setSelectedIndex(f), e.isAdjustingPosition && (e.isAdjustingPosition = !1);
+      }), this.scroll.hooks.on(this.scroll.hooks.eventTypes.refresh, function(l) {
+        l !== u && (u = l, e.setSelectedIndex(e.options.selectedIndex, !0)), e.rotateX(e.scroll.y), e.wheelTo(e.selectedIndex, 0);
+      }), this.scroll.hooks.on(this.scroll.hooks.eventTypes.beforeInitialScrollTo, function(l) {
+        l.x = 0, l.y = -(e.selectedIndex * e.itemHeight);
+      }), n.hooks.on(n.hooks.eventTypes.checkClick, function() {
+        var l = po(e.items).indexOf(e.target);
+        return l === -1 || e.wheelTo(l, e.options.adjustTime, vo.swipe), !0;
+      }), n.hooks.on(n.hooks.eventTypes.scrollTo, function(l) {
+        l.y = e.findNearestValidWheel(l.y).y;
+      }), n.hooks.on(n.hooks.eventTypes.minDistanceScroll, function() {
+        var l = n.animater;
+        l.forceStopped === !0 && (l.forceStopped = !1);
+      }), n.hooks.on(n.hooks.eventTypes.scrollToElement, function(l, f) {
+        if (rt(l, e.options.wheelItemClass))
+          f.top = e.findNearestValidWheel(f.top).y;
+        else
+          return !0;
+      }), o.hooks.on(o.hooks.eventTypes.beforeStart, function(l) {
+        e.target = l.target;
+      }), i.hooks.on(i.hooks.eventTypes.computeBoundary, function(l) {
+        l.maxScrollPos = 0, l.minScrollPos = 0;
+      }), a.hooks.on(a.hooks.eventTypes.computeBoundary, function(l) {
+        e.items = e.scroll.scroller.content.children, e.checkWheelAllDisabled(), e.itemHeight = e.items.length > 0 ? a.contentSize / e.items.length : 0, l.maxScrollPos = -e.itemHeight * (e.items.length - 1), l.minScrollPos = 0;
+      }), a.hooks.on(a.hooks.eventTypes.momentum, function(l) {
+        l.rate = To.rate, l.destination = e.findNearestValidWheel(l.destination).y;
+      }), a.hooks.on(a.hooks.eventTypes.end, function(l) {
+        var f = e.findNearestValidWheel(a.currentPos);
+        l.destination = f.y, l.duration = e.options.adjustTime;
+      }), c.hooks.on(c.hooks.eventTypes.time, function(l) {
+        e.transitionDuration(l);
+      }), c.hooks.on(c.hooks.eventTypes.timeFunction, function(l) {
+        e.timeFunction(l);
+      }), c.hooks.on(c.hooks.eventTypes.callStop, function() {
+        var l = e.findNearestValidWheel(e.scroll.y).index;
+        e.isAdjustingPosition = !0, e.wheelTo(l, 0);
+      }), c.translater.hooks.on(c.translater.hooks.eventTypes.translate, function(l) {
+        e.rotateX(l.y);
+      });
+    }, r.prototype.refreshBoundary = function() {
+      var e = this.scroll.scroller, t = e.scrollBehaviorX, n = e.scrollBehaviorY, o = e.content;
+      t.refresh(o), n.refresh(o);
+    }, r.prototype.setSelectedIndex = function(e, t) {
+      t === void 0 && (t = !1);
+      var n = this.selectedIndex;
+      this.selectedIndex = e, n !== e && !t && this.scroll.trigger(Pr, e);
+    }, r.prototype.getSelectedIndex = function() {
+      return this.selectedIndex;
+    }, r.prototype.wheelTo = function(e, t, n) {
+      e === void 0 && (e = 0), t === void 0 && (t = 0);
+      var o = -e * this.itemHeight;
+      this.scroll.scrollTo(0, o, t, n);
+    }, r.prototype.restorePosition = function() {
+      var e = this.scroll.pending;
+      if (e) {
+        var t = this.getSelectedIndex();
+        this.scroll.scroller.animater.clearTimer(), this.wheelTo(t, 0);
+      }
+    }, r.prototype.transitionDuration = function(e) {
+      for (var t = 0; t < this.items.length; t++)
+        this.items[t].style[wt.transitionDuration] = e + "ms";
+    }, r.prototype.timeFunction = function(e) {
+      for (var t = 0; t < this.items.length; t++)
+        this.items[t].style[wt.transitionTimingFunction] = e;
+    }, r.prototype.rotateX = function(e) {
+      for (var t = this.options.rotate, n = t === void 0 ? 25 : t, o = 0; o < this.items.length; o++) {
+        var i = n * (e / this.itemHeight + o), a = i.toFixed(3);
+        this.items[o].style[wt.transform] = "rotateX(" + a + "deg)";
+      }
+    }, r.prototype.findNearestValidWheel = function(e) {
+      e = e > 0 ? 0 : e < this.scroll.maxScrollY ? this.scroll.maxScrollY : e;
+      for (var t = Math.abs(Math.round(-e / this.itemHeight)), n = t, o = this.items, i = this.options.wheelDisabledItemClass; t >= 0 && rt(o[t], i); )
+        t--;
+      if (t < 0)
+        for (t = n; t <= o.length - 1 && rt(o[t], i); )
+          t++;
+      return t === o.length && (t = n), {
+        index: this.wheelItemsAllDisabled ? -1 : t,
+        y: -t * this.itemHeight
+      };
+    }, r.prototype.checkWheelAllDisabled = function() {
+      var e = this.options.wheelDisabledItemClass, t = this.items;
+      this.wheelItemsAllDisabled = !0;
+      for (var n = 0; n < t.length; n++)
+        if (!rt(t[n], e)) {
+          this.wheelItemsAllDisabled = !1;
+          break;
+        }
+    }, r.pluginName = "wheel", r;
+  }()
+);
+ao.use(Eo);
+const ct = Array.isArray, bo = (r) => typeof r == "string", $r = (r) => typeof r == "number", ko = (r) => typeof r == "object" && r !== null;
+function Ft(r) {
+  return ct(r) && r.length === 3;
+}
+function So(r) {
+  return r % 4 === 0 && (r % 100 !== 0 || r % 400 === 0);
+}
+function Ae(r, e) {
+  const t = [];
+  for (let n = r; n <= e; n++)
+    t.push(n);
+  return t;
+}
+function Ot(r, e) {
+  const t = [];
+  for (let n = r; n <= e; n++)
+    t.push(`${n}`.padStart(2, "0"));
+  return t;
+}
+function Po() {
+  const r = Ot(0, 23), e = Ot(0, 59), t = Ot(0, 59);
+  return {
+    timeList: [r, e, t],
+    getTimeAnchors: xo
+  };
+}
+function xo(r) {
+  return (Ft(r) ? r : Co()).map((t) => Number(t));
+}
+function Co() {
+  const r = /* @__PURE__ */ new Date(), e = r.getHours(), t = r.getMinutes(), n = r.getSeconds();
+  return [e, t, n];
+}
+function wo() {
+  const t = /* @__PURE__ */ new Date(), n = t.getFullYear(), o = t.getMonth() + 1, i = t.getDate(), [a, c] = Xe(n), [u, l] = Xe(o), f = Ae(1900, 2100), p = Ae(1, 12), E = We(() => {
+    const Y = [4, 6, 9, 11], $ = [1, 3, 5, 7, 8, 10, 12];
+    return Y.includes(u) ? Ae(1, 30) : $.includes(u) ? Ae(1, 31) : So(a) ? Ae(1, 29) : Ae(1, 28);
+  }, [u, a]), w = We(() => [f, p, E], [E]);
+  function R(Y) {
+    return (Ft(Y) ? Y : [n, o, i]).map((D, H) => {
+      if (!$r(D)) return 0;
+      const X = w[H].indexOf(D);
+      return X !== -1 ? X : 0;
+    });
+  }
+  function I(Y) {
+    const [$, D] = Y;
+    c(w[0][$]), l(w[1][D]);
+  }
+  return {
+    dateList: w,
+    setSelectYear: c,
+    setSelectMonth: l,
+    updateDateSelect: I,
+    getDateAnchors: R
+  };
+}
+function Oo({
+  data: r,
+  isShowPicker: e,
+  anchor: t,
+  swipeTime: n,
+  type: o,
+  onChangeAnchor: i,
+  onClose: a,
+  onCancel: c,
+  onConfirm: u
+}) {
+  const [l, f] = Xe([]), [p, E] = Xe([]), [w, R] = Xe(!1), I = _t(null), { dateList: Y, setSelectYear: $, setSelectMonth: D, updateDateSelect: H, getDateAnchors: X } = wo(), { timeList: v, getTimeAnchors: te } = Po(), Z = o === "date", V = o === "time", re = We(() => Z ? X(t) : V ? te(t) : ct(t) ? t : [t], [Z, V, t, w]);
+  Ke(() => {
+    ue();
+  }, [r, o, Y]), Ke(() => {
+    e && (oe(), ie(), se());
+  }, [e]), Ke(() => {
+    oe();
+  }, [l]), Ke(() => {
+    se();
+  }, [re]);
+  function oe() {
+    l.forEach((T, k) => q(k)), Q();
+  }
+  function ue() {
+    const T = {
+      date: Y,
+      time: v
+    }, b = ct(r[0]) ? [...r] : [r], P = o ? T[o] : b;
+    f(P);
+  }
+  function ie() {
+    !Z && !V || (Z && H(re), !Ft(t) && R(!w));
+  }
+  function q(T) {
+    var P;
+    const k = (P = I.current) == null ? void 0 : P.children[T];
+    if (!k) return;
+    const b = p[T];
+    if (b)
+      b.refresh();
+    else {
+      const S = Ue(k, {
+        wheel: {
+          selectedIndex: 0,
+          rotate: 25
+        },
+        swipeTime: n
+      });
+      E((C) => {
+        const O = [...C];
+        return O[T] = S, O;
+      }), S.on("scrollEnd", () => K(T, S));
+    }
+  }
+  function K(T, k) {
+    if (Z) {
+      if (T === 2) return;
+      const b = k.getSelectedIndex(), P = Y[T][b];
+      T === 0 && $(P), T === 1 && D(P);
+    }
+  }
+  function se() {
+    setTimeout(() => {
+      p.forEach((T, k) => {
+        const b = re[k];
+        T.wheelTo(b ?? 0);
+      });
+    });
+  }
+  function Q() {
+    const T = l.length;
+    if (p.length <= T) return;
+    const k = p.splice(T);
+    E((b) => b.slice(0, T)), k.forEach((b) => b.destroy());
+  }
+  function ae() {
+    c == null || c(), fe();
+  }
+  function de() {
+    p.some((P) => P.isInTransition) && d();
+    const { item: k, anchor: b } = g();
+    u == null || u(k), i(b), fe();
+  }
+  function fe() {
+    a();
+  }
+  function d() {
+    p.forEach((T) => T.stop());
+  }
+  function g() {
+    const { item: T, anchor: k } = p.reduce(
+      (b, P, S) => {
+        const C = P.getSelectedIndex(), O = l[S][C];
+        return b.item.push(V ? +O : O), b.anchor.push(Z ? O : C), b;
+      },
+      { item: [], anchor: [] }
+    );
+    return T.length > 1 ? { item: T, anchor: k } : { item: T[0], anchor: k[0] };
+  }
+  return {
+    pickerData: l,
+    wheelWrapper: I,
+    cancel: ae,
+    confirm: de,
+    closePicker: fe
+  };
+}
+const _o = {
+  cancelClass: "",
+  confirmClass: "",
+  titleClass: "",
+  cancelColor: "#999",
+  confirmColor: "#42b983",
+  titleColor: "",
+  cancelText: "Cancel",
+  confirmText: "Confirm",
+  titleText: ""
+}, Ro = [], Do = {};
+function Io({
+  data: r = Ro,
+  isShowPicker: e,
+  options: t = Do,
+  anchor: n,
+  showKey: o = "",
+  swipeTime: i = 500,
+  type: a = "",
+  onChangeAnchor: c,
+  onClose: u,
+  onCancel: l,
+  onConfirm: f
+}) {
+  const p = _t(null), E = _t(null), { pickerData: w, wheelWrapper: R, cancel: I, confirm: Y, closePicker: $ } = Oo({
+    data: r,
+    isShowPicker: e,
+    options: t,
+    anchor: n,
+    showKey: o,
+    swipeTime: i,
+    type: a,
+    onClose: u,
+    onChangeAnchor: c,
+    onCancel: l,
+    onConfirm: f
+  }), D = We(() => ({ ..._o, ...t }), [t]), H = D.cancelColor, X = D.confirmColor, v = D.titleColor, te = We(() => ct(o) ? o : [o], [o]);
+  function Z(V) {
+    p.current && p.current.style.setProperty("display", V);
+  }
+  return /* @__PURE__ */ J.jsxs("div", { children: [
+    /* @__PURE__ */ J.jsx(
+      it,
+      {
+        in: e,
+        classNames: "fade",
+        timeout: 300,
+        nodeRef: E,
+        unmountOnExit: !0,
+        children: /* @__PURE__ */ J.jsx(
+          "div",
+          {
+            ref: E,
+            role: "presentation",
+            className: "mask",
+            onClick: $,
+            onKeyDown: (V) => {
+              V.key === "Escape" && $();
+            }
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ J.jsx(
+      it,
+      {
+        in: e,
+        classNames: "slide",
+        timeout: 300,
+        nodeRef: p,
+        onEnter: () => Z(""),
+        onExited: () => Z("none"),
+        children: /* @__PURE__ */ J.jsxs(
+          "div",
+          {
+            ref: p,
+            className: "picker",
+            style: { display: "none" },
+            children: [
+              /* @__PURE__ */ J.jsxs("div", { className: "picker_title", children: [
+                /* @__PURE__ */ J.jsx(
+                  "button",
+                  {
+                    className: `picker_cancel ${D.cancelClass}`,
+                    style: { color: H },
+                    onClick: I,
+                    children: D.cancelText
+                  }
+                ),
+                /* @__PURE__ */ J.jsx(
+                  "button",
+                  {
+                    className: `picker_confirm ${D.confirmClass}`,
+                    style: { color: X },
+                    onClick: Y,
+                    children: D.confirmText
+                  }
+                ),
+                /* @__PURE__ */ J.jsx(
+                  "h4",
+                  {
+                    className: D.titleClass,
+                    style: { color: v },
+                    children: D.titleText
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ J.jsxs("div", { className: "picker_panel", children: [
+                /* @__PURE__ */ J.jsx("div", { className: "picker_mask_top" }),
+                /* @__PURE__ */ J.jsx("div", { className: "picker_mask_bottom" }),
+                /* @__PURE__ */ J.jsx(
+                  "div",
+                  {
+                    ref: R,
+                    className: "picker_wheel_wrapper",
+                    children: w.map((V, re) => /* @__PURE__ */ J.jsx(
+                      "div",
+                      {
+                        className: "picker_wheel",
+                        children: /* @__PURE__ */ J.jsx("ul", { className: "picker_wheel_scroll", children: V.map((oe, ue) => {
+                          const ie = te[re] && ko(oe) ? oe[te[re]] : oe;
+                          return !bo(ie) && !$r(ie) ? null : /* @__PURE__ */ J.jsx(
+                            "li",
+                            {
+                              className: "picker_wheel_item",
+                              children: ie
+                            },
+                            ue
+                          );
+                        }) })
+                      },
+                      re
+                    ))
+                  }
+                )
+              ] })
+            ]
+          }
+        )
+      }
+    )
+  ] });
+}
+export {
+  Io as default
+};