ymy-components 0.0.0

package/dist/ymy-components.es.js

@@ -0,0 +1,2898 @@
+import * as jt from "react";
+import Lr, { useState as Ze, useRef as re, useEffect as ce, useLayoutEffect as Xn, forwardRef as Zn, useCallback as ei, useContext as zr, useMemo as Ge } from "react";
+import { unstable_batchedUpdates as ti } from "react-dom";
+var He = { exports: {} }, Re = {};
+/**
+ * @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 yr;
+function ri() {
+  if (yr) return Re;
+  yr = 1;
+  var e = Lr, t = Symbol.for("react.element"), r = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, s = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, a = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function o(l, d, u) {
+    var m, p = {}, v = null, g = null;
+    u !== void 0 && (v = "" + u), d.key !== void 0 && (v = "" + d.key), d.ref !== void 0 && (g = d.ref);
+    for (m in d) n.call(d, m) && !a.hasOwnProperty(m) && (p[m] = d[m]);
+    if (l && l.defaultProps) for (m in d = l.defaultProps, d) p[m] === void 0 && (p[m] = d[m]);
+    return { $$typeof: t, type: l, key: v, ref: g, props: p, _owner: s.current };
+  }
+  return Re.Fragment = r, Re.jsx = o, Re.jsxs = o, Re;
+}
+var Se = {};
+/**
+ * @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 br;
+function ni() {
+  return br || (br = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = Lr, t = Symbol.for("react.element"), r = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), s = Symbol.for("react.strict_mode"), a = Symbol.for("react.profiler"), o = Symbol.for("react.provider"), l = Symbol.for("react.context"), d = Symbol.for("react.forward_ref"), u = Symbol.for("react.suspense"), m = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), v = Symbol.for("react.lazy"), g = Symbol.for("react.offscreen"), _ = Symbol.iterator, R = "@@iterator";
+    function x(i) {
+      if (i === null || typeof i != "object")
+        return null;
+      var c = _ && i[_] || i[R];
+      return typeof c == "function" ? c : null;
+    }
+    var y = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function b(i) {
+      {
+        for (var c = arguments.length, h = new Array(c > 1 ? c - 1 : 0), w = 1; w < c; w++)
+          h[w - 1] = arguments[w];
+        S("error", i, h);
+      }
+    }
+    function S(i, c, h) {
+      {
+        var w = y.ReactDebugCurrentFrame, C = w.getStackAddendum();
+        C !== "" && (c += "%s", h = h.concat([C]));
+        var O = h.map(function(T) {
+          return String(T);
+        });
+        O.unshift("Warning: " + c), Function.prototype.apply.call(console[i], console, O);
+      }
+    }
+    var k = !1, j = !1, X = !1, U = !1, de = !1, V;
+    V = Symbol.for("react.module.reference");
+    function oe(i) {
+      return !!(typeof i == "string" || typeof i == "function" || i === n || i === a || de || i === s || i === u || i === m || U || i === g || k || j || X || typeof i == "object" && i !== null && (i.$$typeof === v || i.$$typeof === p || i.$$typeof === o || i.$$typeof === l || i.$$typeof === d || // 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.
+      i.$$typeof === V || i.getModuleId !== void 0));
+    }
+    function M(i, c, h) {
+      var w = i.displayName;
+      if (w)
+        return w;
+      var C = c.displayName || c.name || "";
+      return C !== "" ? h + "(" + C + ")" : h;
+    }
+    function Z(i) {
+      return i.displayName || "Context";
+    }
+    function D(i) {
+      if (i == null)
+        return null;
+      if (typeof i.tag == "number" && b("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof i == "function")
+        return i.displayName || i.name || null;
+      if (typeof i == "string")
+        return i;
+      switch (i) {
+        case n:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case a:
+          return "Profiler";
+        case s:
+          return "StrictMode";
+        case u:
+          return "Suspense";
+        case m:
+          return "SuspenseList";
+      }
+      if (typeof i == "object")
+        switch (i.$$typeof) {
+          case l:
+            var c = i;
+            return Z(c) + ".Consumer";
+          case o:
+            var h = i;
+            return Z(h._context) + ".Provider";
+          case d:
+            return M(i, i.render, "ForwardRef");
+          case p:
+            var w = i.displayName || null;
+            return w !== null ? w : D(i.type) || "Memo";
+          case v: {
+            var C = i, O = C._payload, T = C._init;
+            try {
+              return D(T(O));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var ee = Object.assign, _e = 0, Ht, Jt, Kt, Xt, Zt, er, tr;
+    function rr() {
+    }
+    rr.__reactDisabledLog = !0;
+    function xn() {
+      {
+        if (_e === 0) {
+          Ht = console.log, Jt = console.info, Kt = console.warn, Xt = console.error, Zt = console.group, er = console.groupCollapsed, tr = console.groupEnd;
+          var i = {
+            configurable: !0,
+            enumerable: !0,
+            value: rr,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: i,
+            log: i,
+            warn: i,
+            error: i,
+            group: i,
+            groupCollapsed: i,
+            groupEnd: i
+          });
+        }
+        _e++;
+      }
+    }
+    function Pn() {
+      {
+        if (_e--, _e === 0) {
+          var i = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: ee({}, i, {
+              value: Ht
+            }),
+            info: ee({}, i, {
+              value: Jt
+            }),
+            warn: ee({}, i, {
+              value: Kt
+            }),
+            error: ee({}, i, {
+              value: Xt
+            }),
+            group: ee({}, i, {
+              value: Zt
+            }),
+            groupCollapsed: ee({}, i, {
+              value: er
+            }),
+            groupEnd: ee({}, i, {
+              value: tr
+            })
+          });
+        }
+        _e < 0 && b("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var dt = y.ReactCurrentDispatcher, ht;
+    function We(i, c, h) {
+      {
+        if (ht === void 0)
+          try {
+            throw Error();
+          } catch (C) {
+            var w = C.stack.trim().match(/\n( *(at )?)/);
+            ht = w && w[1] || "";
+          }
+        return `
+` + ht + i;
+      }
+    }
+    var mt = !1, Be;
+    {
+      var An = typeof WeakMap == "function" ? WeakMap : Map;
+      Be = new An();
+    }
+    function nr(i, c) {
+      if (!i || mt)
+        return "";
+      {
+        var h = Be.get(i);
+        if (h !== void 0)
+          return h;
+      }
+      var w;
+      mt = !0;
+      var C = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var O;
+      O = dt.current, dt.current = null, xn();
+      try {
+        if (c) {
+          var T = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(T.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(T, []);
+            } catch (N) {
+              w = N;
+            }
+            Reflect.construct(i, [], T);
+          } else {
+            try {
+              T.call();
+            } catch (N) {
+              w = N;
+            }
+            i.call(T.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (N) {
+            w = N;
+          }
+          i();
+        }
+      } catch (N) {
+        if (N && w && typeof N.stack == "string") {
+          for (var P = N.stack.split(`
+`), $ = w.stack.split(`
+`), I = P.length - 1, F = $.length - 1; I >= 1 && F >= 0 && P[I] !== $[F]; )
+            F--;
+          for (; I >= 1 && F >= 0; I--, F--)
+            if (P[I] !== $[F]) {
+              if (I !== 1 || F !== 1)
+                do
+                  if (I--, F--, F < 0 || P[I] !== $[F]) {
+                    var z = `
+` + P[I].replace(" at new ", " at ");
+                    return i.displayName && z.includes("<anonymous>") && (z = z.replace("<anonymous>", i.displayName)), typeof i == "function" && Be.set(i, z), z;
+                  }
+                while (I >= 1 && F >= 0);
+              break;
+            }
+        }
+      } finally {
+        mt = !1, dt.current = O, Pn(), Error.prepareStackTrace = C;
+      }
+      var me = i ? i.displayName || i.name : "", ue = me ? We(me) : "";
+      return typeof i == "function" && Be.set(i, ue), ue;
+    }
+    function Tn(i, c, h) {
+      return nr(i, !1);
+    }
+    function Cn(i) {
+      var c = i.prototype;
+      return !!(c && c.isReactComponent);
+    }
+    function Ye(i, c, h) {
+      if (i == null)
+        return "";
+      if (typeof i == "function")
+        return nr(i, Cn(i));
+      if (typeof i == "string")
+        return We(i);
+      switch (i) {
+        case u:
+          return We("Suspense");
+        case m:
+          return We("SuspenseList");
+      }
+      if (typeof i == "object")
+        switch (i.$$typeof) {
+          case d:
+            return Tn(i.render);
+          case p:
+            return Ye(i.type, c, h);
+          case v: {
+            var w = i, C = w._payload, O = w._init;
+            try {
+              return Ye(O(C), c, h);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var we = Object.prototype.hasOwnProperty, ir = {}, sr = y.ReactDebugCurrentFrame;
+    function Qe(i) {
+      if (i) {
+        var c = i._owner, h = Ye(i.type, i._source, c ? c.type : null);
+        sr.setExtraStackFrame(h);
+      } else
+        sr.setExtraStackFrame(null);
+    }
+    function kn(i, c, h, w, C) {
+      {
+        var O = Function.call.bind(we);
+        for (var T in i)
+          if (O(i, T)) {
+            var P = void 0;
+            try {
+              if (typeof i[T] != "function") {
+                var $ = Error((w || "React class") + ": " + h + " type `" + T + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof i[T] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw $.name = "Invariant Violation", $;
+              }
+              P = i[T](c, T, w, h, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (I) {
+              P = I;
+            }
+            P && !(P instanceof Error) && (Qe(C), b("%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).", w || "React class", h, T, typeof P), Qe(null)), P instanceof Error && !(P.message in ir) && (ir[P.message] = !0, Qe(C), b("Failed %s type: %s", h, P.message), Qe(null));
+          }
+      }
+    }
+    var On = Array.isArray;
+    function pt(i) {
+      return On(i);
+    }
+    function In(i) {
+      {
+        var c = typeof Symbol == "function" && Symbol.toStringTag, h = c && i[Symbol.toStringTag] || i.constructor.name || "Object";
+        return h;
+      }
+    }
+    function Fn(i) {
+      try {
+        return ar(i), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function ar(i) {
+      return "" + i;
+    }
+    function or(i) {
+      if (Fn(i))
+        return b("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", In(i)), ar(i);
+    }
+    var ur = y.ReactCurrentOwner, jn = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, lr, cr;
+    function Vn(i) {
+      if (we.call(i, "ref")) {
+        var c = Object.getOwnPropertyDescriptor(i, "ref").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return i.ref !== void 0;
+    }
+    function Dn(i) {
+      if (we.call(i, "key")) {
+        var c = Object.getOwnPropertyDescriptor(i, "key").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return i.key !== void 0;
+    }
+    function $n(i, c) {
+      typeof i.ref == "string" && ur.current;
+    }
+    function Un(i, c) {
+      {
+        var h = function() {
+          lr || (lr = !0, b("%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)", c));
+        };
+        h.isReactWarning = !0, Object.defineProperty(i, "key", {
+          get: h,
+          configurable: !0
+        });
+      }
+    }
+    function Nn(i, c) {
+      {
+        var h = function() {
+          cr || (cr = !0, b("%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)", c));
+        };
+        h.isReactWarning = !0, Object.defineProperty(i, "ref", {
+          get: h,
+          configurable: !0
+        });
+      }
+    }
+    var qn = function(i, c, h, w, C, O, T) {
+      var P = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: i,
+        key: c,
+        ref: h,
+        props: T,
+        // Record the component responsible for creating this element.
+        _owner: O
+      };
+      return P._store = {}, Object.defineProperty(P._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(P, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: w
+      }), Object.defineProperty(P, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: C
+      }), Object.freeze && (Object.freeze(P.props), Object.freeze(P)), P;
+    };
+    function Mn(i, c, h, w, C) {
+      {
+        var O, T = {}, P = null, $ = null;
+        h !== void 0 && (or(h), P = "" + h), Dn(c) && (or(c.key), P = "" + c.key), Vn(c) && ($ = c.ref, $n(c, C));
+        for (O in c)
+          we.call(c, O) && !jn.hasOwnProperty(O) && (T[O] = c[O]);
+        if (i && i.defaultProps) {
+          var I = i.defaultProps;
+          for (O in I)
+            T[O] === void 0 && (T[O] = I[O]);
+        }
+        if (P || $) {
+          var F = typeof i == "function" ? i.displayName || i.name || "Unknown" : i;
+          P && Un(T, F), $ && Nn(T, F);
+        }
+        return qn(i, P, $, C, w, ur.current, T);
+      }
+    }
+    var vt = y.ReactCurrentOwner, fr = y.ReactDebugCurrentFrame;
+    function he(i) {
+      if (i) {
+        var c = i._owner, h = Ye(i.type, i._source, c ? c.type : null);
+        fr.setExtraStackFrame(h);
+      } else
+        fr.setExtraStackFrame(null);
+    }
+    var gt;
+    gt = !1;
+    function yt(i) {
+      return typeof i == "object" && i !== null && i.$$typeof === t;
+    }
+    function dr() {
+      {
+        if (vt.current) {
+          var i = D(vt.current.type);
+          if (i)
+            return `
+
+Check the render method of \`` + i + "`.";
+        }
+        return "";
+      }
+    }
+    function Ln(i) {
+      return "";
+    }
+    var hr = {};
+    function zn(i) {
+      {
+        var c = dr();
+        if (!c) {
+          var h = typeof i == "string" ? i : i.displayName || i.name;
+          h && (c = `
+
+Check the top-level render call using <` + h + ">.");
+        }
+        return c;
+      }
+    }
+    function mr(i, c) {
+      {
+        if (!i._store || i._store.validated || i.key != null)
+          return;
+        i._store.validated = !0;
+        var h = zn(c);
+        if (hr[h])
+          return;
+        hr[h] = !0;
+        var w = "";
+        i && i._owner && i._owner !== vt.current && (w = " It was passed a child from " + D(i._owner.type) + "."), he(i), b('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', h, w), he(null);
+      }
+    }
+    function pr(i, c) {
+      {
+        if (typeof i != "object")
+          return;
+        if (pt(i))
+          for (var h = 0; h < i.length; h++) {
+            var w = i[h];
+            yt(w) && mr(w, c);
+          }
+        else if (yt(i))
+          i._store && (i._store.validated = !0);
+        else if (i) {
+          var C = x(i);
+          if (typeof C == "function" && C !== i.entries)
+            for (var O = C.call(i), T; !(T = O.next()).done; )
+              yt(T.value) && mr(T.value, c);
+        }
+      }
+    }
+    function Wn(i) {
+      {
+        var c = i.type;
+        if (c == null || typeof c == "string")
+          return;
+        var h;
+        if (typeof c == "function")
+          h = c.propTypes;
+        else if (typeof c == "object" && (c.$$typeof === d || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        c.$$typeof === p))
+          h = c.propTypes;
+        else
+          return;
+        if (h) {
+          var w = D(c);
+          kn(h, i.props, "prop", w, i);
+        } else if (c.PropTypes !== void 0 && !gt) {
+          gt = !0;
+          var C = D(c);
+          b("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", C || "Unknown");
+        }
+        typeof c.getDefaultProps == "function" && !c.getDefaultProps.isReactClassApproved && b("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Bn(i) {
+      {
+        for (var c = Object.keys(i.props), h = 0; h < c.length; h++) {
+          var w = c[h];
+          if (w !== "children" && w !== "key") {
+            he(i), b("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", w), he(null);
+            break;
+          }
+        }
+        i.ref !== null && (he(i), b("Invalid attribute `ref` supplied to `React.Fragment`."), he(null));
+      }
+    }
+    var vr = {};
+    function gr(i, c, h, w, C, O) {
+      {
+        var T = oe(i);
+        if (!T) {
+          var P = "";
+          (i === void 0 || typeof i == "object" && i !== null && Object.keys(i).length === 0) && (P += " 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 $ = Ln();
+          $ ? P += $ : P += dr();
+          var I;
+          i === null ? I = "null" : pt(i) ? I = "array" : i !== void 0 && i.$$typeof === t ? (I = "<" + (D(i.type) || "Unknown") + " />", P = " Did you accidentally export a JSX literal instead of a component?") : I = typeof i, b("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", I, P);
+        }
+        var F = Mn(i, c, h, C, O);
+        if (F == null)
+          return F;
+        if (T) {
+          var z = c.children;
+          if (z !== void 0)
+            if (w)
+              if (pt(z)) {
+                for (var me = 0; me < z.length; me++)
+                  pr(z[me], i);
+                Object.freeze && Object.freeze(z);
+              } else
+                b("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
+              pr(z, i);
+        }
+        if (we.call(c, "key")) {
+          var ue = D(i), N = Object.keys(c).filter(function(Kn) {
+            return Kn !== "key";
+          }), bt = N.length > 0 ? "{key: someKey, " + N.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!vr[ue + bt]) {
+            var Jn = N.length > 0 ? "{" + N.join(": ..., ") + ": ...}" : "{}";
+            b(`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} />`, bt, ue, Jn, ue), vr[ue + bt] = !0;
+          }
+        }
+        return i === n ? Bn(F) : Wn(F), F;
+      }
+    }
+    function Yn(i, c, h) {
+      return gr(i, c, h, !0);
+    }
+    function Qn(i, c, h) {
+      return gr(i, c, h, !1);
+    }
+    var Gn = Qn, Hn = Yn;
+    Se.Fragment = n, Se.jsx = Gn, Se.jsxs = Hn;
+  }()), Se;
+}
+var _r;
+function ii() {
+  return _r || (_r = 1, process.env.NODE_ENV === "production" ? He.exports = ri() : He.exports = ni()), He.exports;
+}
+var J = ii(), Vt = Le(), E = (e) => Me(e, Vt), Dt = Le();
+E.write = (e) => Me(e, Dt);
+var it = Le();
+E.onStart = (e) => Me(e, it);
+var $t = Le();
+E.onFrame = (e) => Me(e, $t);
+var Ut = Le();
+E.onFinish = (e) => Me(e, Ut);
+var ve = [];
+E.setTimeout = (e, t) => {
+  const r = E.now() + t, n = () => {
+    const a = ve.findIndex((o) => o.cancel == n);
+    ~a && ve.splice(a, 1), se -= ~a ? 1 : 0;
+  }, s = { time: r, handler: e, cancel: n };
+  return ve.splice(Wr(r), 0, s), se += 1, Br(), s;
+};
+var Wr = (e) => ~(~ve.findIndex((t) => t.time > e) || ~ve.length);
+E.cancel = (e) => {
+  it.delete(e), $t.delete(e), Ut.delete(e), Vt.delete(e), Dt.delete(e);
+};
+E.sync = (e) => {
+  Pt = !0, E.batchedUpdates(e), Pt = !1;
+};
+E.throttle = (e) => {
+  let t;
+  function r() {
+    try {
+      e(...t);
+    } finally {
+      t = null;
+    }
+  }
+  function n(...s) {
+    t = s, E.onStart(r);
+  }
+  return n.handler = e, n.cancel = () => {
+    it.delete(r), t = null;
+  }, n;
+};
+var Nt = typeof window < "u" ? window.requestAnimationFrame : (
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  () => {
+  }
+);
+E.use = (e) => Nt = e;
+E.now = typeof performance < "u" ? () => performance.now() : Date.now;
+E.batchedUpdates = (e) => e();
+E.catch = console.error;
+E.frameLoop = "always";
+E.advance = () => {
+  E.frameLoop !== "demand" ? console.warn(
+    "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"
+  ) : Qr();
+};
+var ie = -1, se = 0, Pt = !1;
+function Me(e, t) {
+  Pt ? (t.delete(e), e(0)) : (t.add(e), Br());
+}
+function Br() {
+  ie < 0 && (ie = 0, E.frameLoop !== "demand" && Nt(Yr));
+}
+function si() {
+  ie = -1;
+}
+function Yr() {
+  ~ie && (Nt(Yr), E.batchedUpdates(Qr));
+}
+function Qr() {
+  const e = ie;
+  ie = E.now();
+  const t = Wr(ie);
+  if (t && (Gr(ve.splice(0, t), (r) => r.handler()), se -= t), !se) {
+    si();
+    return;
+  }
+  it.flush(), Vt.flush(e ? Math.min(64, ie - e) : 16.667), $t.flush(), Dt.flush(), Ut.flush();
+}
+function Le() {
+  let e = /* @__PURE__ */ new Set(), t = e;
+  return {
+    add(r) {
+      se += t == e && !e.has(r) ? 1 : 0, e.add(r);
+    },
+    delete(r) {
+      return se -= t == e && e.has(r) ? 1 : 0, e.delete(r);
+    },
+    flush(r) {
+      t.size && (e = /* @__PURE__ */ new Set(), se -= t.size, Gr(t, (n) => n(r) && e.add(n)), se += e.size, t = e);
+    }
+  };
+}
+function Gr(e, t) {
+  e.forEach((r) => {
+    try {
+      t(r);
+    } catch (n) {
+      E.catch(n);
+    }
+  });
+}
+var ai = Object.defineProperty, oi = (e, t) => {
+  for (var r in t)
+    ai(e, r, { get: t[r], enumerable: !0 });
+}, G = {};
+oi(G, {
+  assign: () => li,
+  colors: () => ae,
+  createStringInterpolator: () => Mt,
+  skipAnimation: () => Jr,
+  to: () => Hr,
+  willAdvance: () => Lt
+});
+function At() {
+}
+var ui = (e, t, r) => Object.defineProperty(e, t, { value: r, writable: !0, configurable: !0 }), f = {
+  arr: Array.isArray,
+  obj: (e) => !!e && e.constructor.name === "Object",
+  fun: (e) => typeof e == "function",
+  str: (e) => typeof e == "string",
+  num: (e) => typeof e == "number",
+  und: (e) => e === void 0
+};
+function te(e, t) {
+  if (f.arr(e)) {
+    if (!f.arr(t) || e.length !== t.length)
+      return !1;
+    for (let r = 0; r < e.length; r++)
+      if (e[r] !== t[r])
+        return !1;
+    return !0;
+  }
+  return e === t;
+}
+var A = (e, t) => e.forEach(t);
+function K(e, t, r) {
+  if (f.arr(e)) {
+    for (let n = 0; n < e.length; n++)
+      t.call(r, e[n], `${n}`);
+    return;
+  }
+  for (const n in e)
+    e.hasOwnProperty(n) && t.call(r, e[n], n);
+}
+var L = (e) => f.und(e) ? [] : f.arr(e) ? e : [e];
+function Te(e, t) {
+  if (e.size) {
+    const r = Array.from(e);
+    e.clear(), A(r, t);
+  }
+}
+var Ae = (e, ...t) => Te(e, (r) => r(...t)), qt = () => typeof window > "u" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent), Mt, Hr, ae = null, Jr = !1, Lt = At, li = (e) => {
+  e.to && (Hr = e.to), e.now && (E.now = e.now), e.colors !== void 0 && (ae = e.colors), e.skipAnimation != null && (Jr = e.skipAnimation), e.createStringInterpolator && (Mt = e.createStringInterpolator), e.requestAnimationFrame && E.use(e.requestAnimationFrame), e.batchedUpdates && (E.batchedUpdates = e.batchedUpdates), e.willAdvance && (Lt = e.willAdvance), e.frameLoop && (E.frameLoop = e.frameLoop);
+}, Ce = /* @__PURE__ */ new Set(), B = [], _t = [], et = 0, st = {
+  get idle() {
+    return !Ce.size && !B.length;
+  },
+  /** Advance the given animation on every frame until idle. */
+  start(e) {
+    et > e.priority ? (Ce.add(e), E.onStart(ci)) : (Kr(e), E(Tt));
+  },
+  /** Advance all animations by the given time. */
+  advance: Tt,
+  /** Call this when an animation's priority changes. */
+  sort(e) {
+    if (et)
+      E.onFrame(() => st.sort(e));
+    else {
+      const t = B.indexOf(e);
+      ~t && (B.splice(t, 1), Xr(e));
+    }
+  },
+  /**
+   * Clear all animations. For testing purposes.
+   *
+   * ☠️ Never call this from within the frameloop.
+   */
+  clear() {
+    B = [], Ce.clear();
+  }
+};
+function ci() {
+  Ce.forEach(Kr), Ce.clear(), E(Tt);
+}
+function Kr(e) {
+  B.includes(e) || Xr(e);
+}
+function Xr(e) {
+  B.splice(
+    fi(B, (t) => t.priority > e.priority),
+    0,
+    e
+  );
+}
+function Tt(e) {
+  const t = _t;
+  for (let r = 0; r < B.length; r++) {
+    const n = B[r];
+    et = n.priority, n.idle || (Lt(n), n.advance(e), n.idle || t.push(n));
+  }
+  return et = 0, _t = B, _t.length = 0, B = t, B.length > 0;
+}
+function fi(e, t) {
+  const r = e.findIndex(t);
+  return r < 0 ? e.length : r;
+}
+var di = {
+  transparent: 0,
+  aliceblue: 4042850303,
+  antiquewhite: 4209760255,
+  aqua: 16777215,
+  aquamarine: 2147472639,
+  azure: 4043309055,
+  beige: 4126530815,
+  bisque: 4293182719,
+  black: 255,
+  blanchedalmond: 4293643775,
+  blue: 65535,
+  blueviolet: 2318131967,
+  brown: 2771004159,
+  burlywood: 3736635391,
+  burntsienna: 3934150143,
+  cadetblue: 1604231423,
+  chartreuse: 2147418367,
+  chocolate: 3530104575,
+  coral: 4286533887,
+  cornflowerblue: 1687547391,
+  cornsilk: 4294499583,
+  crimson: 3692313855,
+  cyan: 16777215,
+  darkblue: 35839,
+  darkcyan: 9145343,
+  darkgoldenrod: 3095792639,
+  darkgray: 2846468607,
+  darkgreen: 6553855,
+  darkgrey: 2846468607,
+  darkkhaki: 3182914559,
+  darkmagenta: 2332068863,
+  darkolivegreen: 1433087999,
+  darkorange: 4287365375,
+  darkorchid: 2570243327,
+  darkred: 2332033279,
+  darksalmon: 3918953215,
+  darkseagreen: 2411499519,
+  darkslateblue: 1211993087,
+  darkslategray: 793726975,
+  darkslategrey: 793726975,
+  darkturquoise: 13554175,
+  darkviolet: 2483082239,
+  deeppink: 4279538687,
+  deepskyblue: 12582911,
+  dimgray: 1768516095,
+  dimgrey: 1768516095,
+  dodgerblue: 512819199,
+  firebrick: 2988581631,
+  floralwhite: 4294635775,
+  forestgreen: 579543807,
+  fuchsia: 4278255615,
+  gainsboro: 3705462015,
+  ghostwhite: 4177068031,
+  gold: 4292280575,
+  goldenrod: 3668254975,
+  gray: 2155905279,
+  green: 8388863,
+  greenyellow: 2919182335,
+  grey: 2155905279,
+  honeydew: 4043305215,
+  hotpink: 4285117695,
+  indianred: 3445382399,
+  indigo: 1258324735,
+  ivory: 4294963455,
+  khaki: 4041641215,
+  lavender: 3873897215,
+  lavenderblush: 4293981695,
+  lawngreen: 2096890111,
+  lemonchiffon: 4294626815,
+  lightblue: 2916673279,
+  lightcoral: 4034953471,
+  lightcyan: 3774873599,
+  lightgoldenrodyellow: 4210742015,
+  lightgray: 3553874943,
+  lightgreen: 2431553791,
+  lightgrey: 3553874943,
+  lightpink: 4290167295,
+  lightsalmon: 4288707327,
+  lightseagreen: 548580095,
+  lightskyblue: 2278488831,
+  lightslategray: 2005441023,
+  lightslategrey: 2005441023,
+  lightsteelblue: 2965692159,
+  lightyellow: 4294959359,
+  lime: 16711935,
+  limegreen: 852308735,
+  linen: 4210091775,
+  magenta: 4278255615,
+  maroon: 2147483903,
+  mediumaquamarine: 1724754687,
+  mediumblue: 52735,
+  mediumorchid: 3126187007,
+  mediumpurple: 2473647103,
+  mediumseagreen: 1018393087,
+  mediumslateblue: 2070474495,
+  mediumspringgreen: 16423679,
+  mediumturquoise: 1221709055,
+  mediumvioletred: 3340076543,
+  midnightblue: 421097727,
+  mintcream: 4127193855,
+  mistyrose: 4293190143,
+  moccasin: 4293178879,
+  navajowhite: 4292783615,
+  navy: 33023,
+  oldlace: 4260751103,
+  olive: 2155872511,
+  olivedrab: 1804477439,
+  orange: 4289003775,
+  orangered: 4282712319,
+  orchid: 3664828159,
+  palegoldenrod: 4008225535,
+  palegreen: 2566625535,
+  paleturquoise: 2951671551,
+  palevioletred: 3681588223,
+  papayawhip: 4293907967,
+  peachpuff: 4292524543,
+  peru: 3448061951,
+  pink: 4290825215,
+  plum: 3718307327,
+  powderblue: 2967529215,
+  purple: 2147516671,
+  rebeccapurple: 1714657791,
+  red: 4278190335,
+  rosybrown: 3163525119,
+  royalblue: 1097458175,
+  saddlebrown: 2336560127,
+  salmon: 4202722047,
+  sandybrown: 4104413439,
+  seagreen: 780883967,
+  seashell: 4294307583,
+  sienna: 2689740287,
+  silver: 3233857791,
+  skyblue: 2278484991,
+  slateblue: 1784335871,
+  slategray: 1887473919,
+  slategrey: 1887473919,
+  snow: 4294638335,
+  springgreen: 16744447,
+  steelblue: 1182971135,
+  tan: 3535047935,
+  teal: 8421631,
+  thistle: 3636451583,
+  tomato: 4284696575,
+  turquoise: 1088475391,
+  violet: 4001558271,
+  wheat: 4125012991,
+  white: 4294967295,
+  whitesmoke: 4126537215,
+  yellow: 4294902015,
+  yellowgreen: 2597139199
+}, Q = "[-+]?\\d*\\.?\\d+", tt = Q + "%";
+function at(...e) {
+  return "\\(\\s*(" + e.join(")\\s*,\\s*(") + ")\\s*\\)";
+}
+var hi = new RegExp("rgb" + at(Q, Q, Q)), mi = new RegExp("rgba" + at(Q, Q, Q, Q)), pi = new RegExp("hsl" + at(Q, tt, tt)), vi = new RegExp(
+  "hsla" + at(Q, tt, tt, Q)
+), gi = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, yi = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, bi = /^#([0-9a-fA-F]{6})$/, _i = /^#([0-9a-fA-F]{8})$/;
+function wi(e) {
+  let t;
+  return typeof e == "number" ? e >>> 0 === e && e >= 0 && e <= 4294967295 ? e : null : (t = bi.exec(e)) ? parseInt(t[1] + "ff", 16) >>> 0 : ae && ae[e] !== void 0 ? ae[e] : (t = hi.exec(e)) ? (pe(t[1]) << 24 | // r
+  pe(t[2]) << 16 | // g
+  pe(t[3]) << 8 | // b
+  255) >>> // a
+  0 : (t = mi.exec(e)) ? (pe(t[1]) << 24 | // r
+  pe(t[2]) << 16 | // g
+  pe(t[3]) << 8 | // b
+  Sr(t[4])) >>> // a
+  0 : (t = gi.exec(e)) ? parseInt(
+    t[1] + t[1] + // r
+    t[2] + t[2] + // g
+    t[3] + t[3] + // b
+    "ff",
+    // a
+    16
+  ) >>> 0 : (t = _i.exec(e)) ? parseInt(t[1], 16) >>> 0 : (t = yi.exec(e)) ? parseInt(
+    t[1] + t[1] + // r
+    t[2] + t[2] + // g
+    t[3] + t[3] + // b
+    t[4] + t[4],
+    // a
+    16
+  ) >>> 0 : (t = pi.exec(e)) ? (wr(
+    Rr(t[1]),
+    // h
+    Je(t[2]),
+    // s
+    Je(t[3])
+    // l
+  ) | 255) >>> // a
+  0 : (t = vi.exec(e)) ? (wr(
+    Rr(t[1]),
+    // h
+    Je(t[2]),
+    // s
+    Je(t[3])
+    // l
+  ) | Sr(t[4])) >>> // a
+  0 : null;
+}
+function wt(e, t, r) {
+  return r < 0 && (r += 1), r > 1 && (r -= 1), r < 1 / 6 ? e + (t - e) * 6 * r : r < 1 / 2 ? t : r < 2 / 3 ? e + (t - e) * (2 / 3 - r) * 6 : e;
+}
+function wr(e, t, r) {
+  const n = r < 0.5 ? r * (1 + t) : r + t - r * t, s = 2 * r - n, a = wt(s, n, e + 1 / 3), o = wt(s, n, e), l = wt(s, n, e - 1 / 3);
+  return Math.round(a * 255) << 24 | Math.round(o * 255) << 16 | Math.round(l * 255) << 8;
+}
+function pe(e) {
+  const t = parseInt(e, 10);
+  return t < 0 ? 0 : t > 255 ? 255 : t;
+}
+function Rr(e) {
+  return (parseFloat(e) % 360 + 360) % 360 / 360;
+}
+function Sr(e) {
+  const t = parseFloat(e);
+  return t < 0 ? 0 : t > 1 ? 255 : Math.round(t * 255);
+}
+function Je(e) {
+  const t = parseFloat(e);
+  return t < 0 ? 0 : t > 100 ? 1 : t / 100;
+}
+function Er(e) {
+  let t = wi(e);
+  if (t === null)
+    return e;
+  t = t || 0;
+  const r = (t & 4278190080) >>> 24, n = (t & 16711680) >>> 16, s = (t & 65280) >>> 8, a = (t & 255) / 255;
+  return `rgba(${r}, ${n}, ${s}, ${a})`;
+}
+var Ie = (e, t, r) => {
+  if (f.fun(e))
+    return e;
+  if (f.arr(e))
+    return Ie({
+      range: e,
+      output: t,
+      extrapolate: r
+    });
+  if (f.str(e.output[0]))
+    return Mt(e);
+  const n = e, s = n.output, a = n.range || [0, 1], o = n.extrapolateLeft || n.extrapolate || "extend", l = n.extrapolateRight || n.extrapolate || "extend", d = n.easing || ((u) => u);
+  return (u) => {
+    const m = Si(u, a);
+    return Ri(
+      u,
+      a[m],
+      a[m + 1],
+      s[m],
+      s[m + 1],
+      d,
+      o,
+      l,
+      n.map
+    );
+  };
+};
+function Ri(e, t, r, n, s, a, o, l, d) {
+  let u = d ? d(e) : e;
+  if (u < t) {
+    if (o === "identity")
+      return u;
+    o === "clamp" && (u = t);
+  }
+  if (u > r) {
+    if (l === "identity")
+      return u;
+    l === "clamp" && (u = r);
+  }
+  return n === s ? n : t === r ? e <= t ? n : s : (t === -1 / 0 ? u = -u : r === 1 / 0 ? u = u - t : u = (u - t) / (r - t), u = a(u), n === -1 / 0 ? u = -u : s === 1 / 0 ? u = u + n : u = u * (s - n) + n, u);
+}
+function Si(e, t) {
+  for (var r = 1; r < t.length - 1 && !(t[r] >= e); ++r)
+    ;
+  return r - 1;
+}
+var Ei = {
+  linear: (e) => e
+}, Fe = Symbol.for("FluidValue.get"), ye = Symbol.for("FluidValue.observers"), W = (e) => !!(e && e[Fe]), q = (e) => e && e[Fe] ? e[Fe]() : e, xr = (e) => e[ye] || null;
+function xi(e, t) {
+  e.eventObserved ? e.eventObserved(t) : e(t);
+}
+function je(e, t) {
+  const r = e[ye];
+  r && r.forEach((n) => {
+    xi(n, t);
+  });
+}
+var Zr = class {
+  constructor(e) {
+    if (!e && !(e = this.get))
+      throw Error("Unknown getter");
+    Pi(this, e);
+  }
+}, Pi = (e, t) => en(e, Fe, t);
+function be(e, t) {
+  if (e[Fe]) {
+    let r = e[ye];
+    r || en(e, ye, r = /* @__PURE__ */ new Set()), r.has(t) || (r.add(t), e.observerAdded && e.observerAdded(r.size, t));
+  }
+  return t;
+}
+function Ve(e, t) {
+  const r = e[ye];
+  if (r && r.has(t)) {
+    const n = r.size - 1;
+    n ? r.delete(t) : e[ye] = null, e.observerRemoved && e.observerRemoved(n, t);
+  }
+}
+var en = (e, t, r) => Object.defineProperty(e, t, {
+  value: r,
+  writable: !0,
+  configurable: !0
+}), Ke = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, Ai = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi, Pr = new RegExp(`(${Ke.source})(%|[a-z]+)`, "i"), Ti = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, ot = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/, tn = (e) => {
+  const [t, r] = Ci(e);
+  if (!t || qt())
+    return e;
+  const n = window.getComputedStyle(document.documentElement).getPropertyValue(t);
+  if (n)
+    return n.trim();
+  if (r && r.startsWith("--")) {
+    const s = window.getComputedStyle(document.documentElement).getPropertyValue(r);
+    return s || e;
+  } else {
+    if (r && ot.test(r))
+      return tn(r);
+    if (r)
+      return r;
+  }
+  return e;
+}, Ci = (e) => {
+  const t = ot.exec(e);
+  if (!t)
+    return [,];
+  const [, r, n] = t;
+  return [r, n];
+}, Rt, ki = (e, t, r, n, s) => `rgba(${Math.round(t)}, ${Math.round(r)}, ${Math.round(n)}, ${s})`, rn = (e) => {
+  Rt || (Rt = ae ? (
+    // match color names, ignore partial matches
+    new RegExp(`(${Object.keys(ae).join("|")})(?!\\w)`, "g")
+  ) : (
+    // never match
+    /^\b$/
+  ));
+  const t = e.output.map((a) => q(a).replace(ot, tn).replace(Ai, Er).replace(Rt, Er)), r = t.map((a) => a.match(Ke).map(Number)), s = r[0].map(
+    (a, o) => r.map((l) => {
+      if (!(o in l))
+        throw Error('The arity of each "output" value must be equal');
+      return l[o];
+    })
+  ).map(
+    (a) => Ie({ ...e, output: a })
+  );
+  return (a) => {
+    var d;
+    const o = !Pr.test(t[0]) && ((d = t.find((u) => Pr.test(u))) == null ? void 0 : d.replace(Ke, ""));
+    let l = 0;
+    return t[0].replace(
+      Ke,
+      () => `${s[l++](a)}${o || ""}`
+    ).replace(Ti, ki);
+  };
+}, zt = "react-spring: ", nn = (e) => {
+  const t = e;
+  let r = !1;
+  if (typeof t != "function")
+    throw new TypeError(`${zt}once requires a function parameter`);
+  return (...n) => {
+    r || (t(...n), r = !0);
+  };
+}, Oi = nn(console.warn);
+function Ii() {
+  Oi(
+    `${zt}The "interpolate" function is deprecated in v9 (use "to" instead)`
+  );
+}
+var Fi = nn(console.warn);
+function ji() {
+  Fi(
+    `${zt}Directly calling start instead of using the api object is deprecated in v9 (use ".start" instead), this will be removed in later 0.X.0 versions`
+  );
+}
+function ut(e) {
+  return f.str(e) && (e[0] == "#" || /\d/.test(e) || // Do not identify a CSS variable as an AnimatedString if its SSR
+  !qt() && ot.test(e) || e in (ae || {}));
+}
+var Wt = qt() ? ce : Xn, Vi = () => {
+  const e = re(!1);
+  return Wt(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), e;
+};
+function sn() {
+  const e = Ze()[1], t = Vi();
+  return () => {
+    t.current && e(Math.random());
+  };
+}
+function Di(e, t) {
+  const [r] = Ze(
+    () => ({
+      inputs: t,
+      result: e()
+    })
+  ), n = re(), s = n.current;
+  let a = s;
+  return a ? t && a.inputs && $i(t, a.inputs) || (a = {
+    inputs: t,
+    result: e()
+  }) : a = r, ce(() => {
+    n.current = a, s == r && (r.inputs = r.result = void 0);
+  }, [a]), a.result;
+}
+function $i(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (let r = 0; r < e.length; r++)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+var an = (e) => ce(e, Ui), Ui = [];
+function Ar(e) {
+  const t = re();
+  return ce(() => {
+    t.current = e;
+  }), t.current;
+}
+var De = Symbol.for("Animated:node"), Ni = (e) => !!e && e[De] === e, H = (e) => e && e[De], Bt = (e, t) => ui(e, De, t), lt = (e) => e && e[De] && e[De].getPayload(), on = class {
+  constructor() {
+    Bt(this, this);
+  }
+  /** Get every `AnimatedValue` used by this node. */
+  getPayload() {
+    return this.payload || [];
+  }
+}, ze = class extends on {
+  constructor(e) {
+    super(), this._value = e, this.done = !0, this.durationProgress = 0, f.num(this._value) && (this.lastPosition = this._value);
+  }
+  /** @internal */
+  static create(e) {
+    return new ze(e);
+  }
+  getPayload() {
+    return [this];
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(e, t) {
+    return f.num(e) && (this.lastPosition = e, t && (e = Math.round(e / t) * t, this.done && (this.lastPosition = e))), this._value === e ? !1 : (this._value = e, !0);
+  }
+  reset() {
+    const { done: e } = this;
+    this.done = !1, f.num(this._value) && (this.elapsedTime = 0, this.durationProgress = 0, this.lastPosition = this._value, e && (this.lastVelocity = null), this.v0 = null);
+  }
+}, $e = class extends ze {
+  constructor(e) {
+    super(0), this._string = null, this._toString = Ie({
+      output: [e, e]
+    });
+  }
+  /** @internal */
+  static create(e) {
+    return new $e(e);
+  }
+  getValue() {
+    const e = this._string;
+    return e ?? (this._string = this._toString(this._value));
+  }
+  setValue(e) {
+    if (f.str(e)) {
+      if (e == this._string)
+        return !1;
+      this._string = e, this._value = 1;
+    } else if (super.setValue(e))
+      this._string = null;
+    else
+      return !1;
+    return !0;
+  }
+  reset(e) {
+    e && (this._toString = Ie({
+      output: [this.getValue(), e]
+    })), this._value = 0, super.reset();
+  }
+}, rt = { dependencies: null }, ct = class extends on {
+  constructor(e) {
+    super(), this.source = e, this.setValue(e);
+  }
+  getValue(e) {
+    const t = {};
+    return K(this.source, (r, n) => {
+      Ni(r) ? t[n] = r.getValue(e) : W(r) ? t[n] = q(r) : e || (t[n] = r);
+    }), t;
+  }
+  /** Replace the raw object data */
+  setValue(e) {
+    this.source = e, this.payload = this._makePayload(e);
+  }
+  reset() {
+    this.payload && A(this.payload, (e) => e.reset());
+  }
+  /** Create a payload set. */
+  _makePayload(e) {
+    if (e) {
+      const t = /* @__PURE__ */ new Set();
+      return K(e, this._addToPayload, t), Array.from(t);
+    }
+  }
+  /** Add to a payload set. */
+  _addToPayload(e) {
+    rt.dependencies && W(e) && rt.dependencies.add(e);
+    const t = lt(e);
+    t && A(t, (r) => this.add(r));
+  }
+}, un = class extends ct {
+  constructor(e) {
+    super(e);
+  }
+  /** @internal */
+  static create(e) {
+    return new un(e);
+  }
+  getValue() {
+    return this.source.map((e) => e.getValue());
+  }
+  setValue(e) {
+    const t = this.getPayload();
+    return e.length == t.length ? t.map((r, n) => r.setValue(e[n])).some(Boolean) : (super.setValue(e.map(qi)), !0);
+  }
+};
+function qi(e) {
+  return (ut(e) ? $e : ze).create(e);
+}
+function Ct(e) {
+  const t = H(e);
+  return t ? t.constructor : f.arr(e) ? un : ut(e) ? $e : ze;
+}
+var Tr = (e, t) => {
+  const r = (
+    // Function components must use "forwardRef" to avoid being
+    // re-rendered on every animation frame.
+    !f.fun(e) || e.prototype && e.prototype.isReactComponent
+  );
+  return Zn((n, s) => {
+    const a = re(null), o = r && // eslint-disable-next-line react-hooks/rules-of-hooks
+    ei(
+      (_) => {
+        a.current = zi(s, _);
+      },
+      [s]
+    ), [l, d] = Li(n, t), u = sn(), m = () => {
+      const _ = a.current;
+      if (r && !_)
+        return;
+      (_ ? t.applyAnimatedValues(_, l.getValue(!0)) : !1) === !1 && u();
+    }, p = new Mi(m, d), v = re();
+    Wt(() => (v.current = p, A(d, (_) => be(_, p)), () => {
+      v.current && (A(
+        v.current.deps,
+        (_) => Ve(_, v.current)
+      ), E.cancel(v.current.update));
+    })), ce(m, []), an(() => () => {
+      const _ = v.current;
+      A(_.deps, (R) => Ve(R, _));
+    });
+    const g = t.getComponentProps(l.getValue());
+    return /* @__PURE__ */ jt.createElement(e, { ...g, ref: o });
+  });
+}, Mi = class {
+  constructor(e, t) {
+    this.update = e, this.deps = t;
+  }
+  eventObserved(e) {
+    e.type == "change" && E.write(this.update);
+  }
+};
+function Li(e, t) {
+  const r = /* @__PURE__ */ new Set();
+  return rt.dependencies = r, e.style && (e = {
+    ...e,
+    style: t.createAnimatedStyle(e.style)
+  }), e = new ct(e), rt.dependencies = null, [e, r];
+}
+function zi(e, t) {
+  return e && (f.fun(e) ? e(t) : e.current = t), t;
+}
+var Cr = Symbol.for("AnimatedComponent"), Wi = (e, {
+  applyAnimatedValues: t = () => !1,
+  createAnimatedStyle: r = (s) => new ct(s),
+  getComponentProps: n = (s) => s
+} = {}) => {
+  const s = {
+    applyAnimatedValues: t,
+    createAnimatedStyle: r,
+    getComponentProps: n
+  }, a = (o) => {
+    const l = kr(o) || "Anonymous";
+    return f.str(o) ? o = a[o] || (a[o] = Tr(o, s)) : o = o[Cr] || (o[Cr] = Tr(o, s)), o.displayName = `Animated(${l})`, o;
+  };
+  return K(e, (o, l) => {
+    f.arr(e) && (l = kr(o)), a[l] = a(o);
+  }), {
+    animated: a
+  };
+}, kr = (e) => f.str(e) ? e : e && f.str(e.displayName) ? e.displayName : f.fun(e) && e.name || null;
+function le(e, ...t) {
+  return f.fun(e) ? e(...t) : e;
+}
+var ke = (e, t) => e === !0 || !!(t && e && (f.fun(e) ? e(t) : L(e).includes(t))), ln = (e, t) => f.obj(e) ? t && e[t] : e, cn = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, Bi = (e) => e, Yt = (e, t = Bi) => {
+  let r = Yi;
+  e.default && e.default !== !0 && (e = e.default, r = Object.keys(e));
+  const n = {};
+  for (const s of r) {
+    const a = t(e[s], s);
+    f.und(a) || (n[s] = a);
+  }
+  return n;
+}, Yi = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+], Qi = {
+  config: 1,
+  from: 1,
+  to: 1,
+  ref: 1,
+  loop: 1,
+  reset: 1,
+  pause: 1,
+  cancel: 1,
+  reverse: 1,
+  immediate: 1,
+  default: 1,
+  delay: 1,
+  onProps: 1,
+  onStart: 1,
+  onChange: 1,
+  onPause: 1,
+  onResume: 1,
+  onRest: 1,
+  onResolve: 1,
+  // Transition props
+  items: 1,
+  trail: 1,
+  sort: 1,
+  expires: 1,
+  initial: 1,
+  enter: 1,
+  update: 1,
+  leave: 1,
+  children: 1,
+  onDestroyed: 1,
+  // Internal props
+  keys: 1,
+  callId: 1,
+  parentId: 1
+};
+function Gi(e) {
+  const t = {};
+  let r = 0;
+  if (K(e, (n, s) => {
+    Qi[s] || (t[s] = n, r++);
+  }), r)
+    return t;
+}
+function fn(e) {
+  const t = Gi(e);
+  if (t) {
+    const r = { to: t };
+    return K(e, (n, s) => s in t || (r[s] = n)), r;
+  }
+  return { ...e };
+}
+function Ue(e) {
+  return e = q(e), f.arr(e) ? e.map(Ue) : ut(e) ? G.createStringInterpolator({
+    range: [0, 1],
+    output: [e, e]
+  })(1) : e;
+}
+function Hi(e) {
+  for (const t in e)
+    return !0;
+  return !1;
+}
+function kt(e) {
+  return f.fun(e) || f.arr(e) && f.obj(e[0]);
+}
+function Ji(e, t) {
+  var r;
+  (r = e.ref) == null || r.delete(e), t == null || t.delete(e);
+}
+function Ki(e, t) {
+  var r;
+  t && e.ref !== t && ((r = e.ref) == null || r.delete(e), t.add(e), e.ref = t);
+}
+var Xi = {
+  default: { tension: 170, friction: 26 }
+}, Ot = {
+  ...Xi.default,
+  mass: 1,
+  damping: 1,
+  easing: Ei.linear,
+  clamp: !1
+}, Zi = class {
+  constructor() {
+    this.velocity = 0, Object.assign(this, Ot);
+  }
+};
+function es(e, t, r) {
+  r && (r = { ...r }, Or(r, t), t = { ...r, ...t }), Or(e, t), Object.assign(e, t);
+  for (const o in Ot)
+    e[o] == null && (e[o] = Ot[o]);
+  let { frequency: n, damping: s } = e;
+  const { mass: a } = e;
+  return f.und(n) || (n < 0.01 && (n = 0.01), s < 0 && (s = 0), e.tension = Math.pow(2 * Math.PI / n, 2) * a, e.friction = 4 * Math.PI * s * a / n), e;
+}
+function Or(e, t) {
+  if (!f.und(t.decay))
+    e.duration = void 0;
+  else {
+    const r = !f.und(t.tension) || !f.und(t.friction);
+    (r || !f.und(t.frequency) || !f.und(t.damping) || !f.und(t.mass)) && (e.duration = void 0, e.decay = void 0), r && (e.frequency = void 0);
+  }
+}
+var Ir = [], ts = class {
+  constructor() {
+    this.changed = !1, this.values = Ir, this.toValues = null, this.fromValues = Ir, this.config = new Zi(), this.immediate = !1;
+  }
+};
+function dn(e, { key: t, props: r, defaultProps: n, state: s, actions: a }) {
+  return new Promise((o, l) => {
+    let d, u, m = ke(r.cancel ?? (n == null ? void 0 : n.cancel), t);
+    if (m)
+      g();
+    else {
+      f.und(r.pause) || (s.paused = ke(r.pause, t));
+      let _ = n == null ? void 0 : n.pause;
+      _ !== !0 && (_ = s.paused || ke(_, t)), d = le(r.delay || 0, t), _ ? (s.resumeQueue.add(v), a.pause()) : (a.resume(), v());
+    }
+    function p() {
+      s.resumeQueue.add(v), s.timeouts.delete(u), u.cancel(), d = u.time - E.now();
+    }
+    function v() {
+      d > 0 && !G.skipAnimation ? (s.delayed = !0, u = E.setTimeout(g, d), s.pauseQueue.add(p), s.timeouts.add(u)) : g();
+    }
+    function g() {
+      s.delayed && (s.delayed = !1), s.pauseQueue.delete(p), s.timeouts.delete(u), e <= (s.cancelId || 0) && (m = !0);
+      try {
+        a.start({ ...r, callId: e, cancel: m }, o);
+      } catch (_) {
+        l(_);
+      }
+    }
+  });
+}
+var Qt = (e, t) => t.length == 1 ? t[0] : t.some((r) => r.cancelled) ? ge(e.get()) : t.every((r) => r.noop) ? hn(e.get()) : Y(
+  e.get(),
+  t.every((r) => r.finished)
+), hn = (e) => ({
+  value: e,
+  noop: !0,
+  finished: !0,
+  cancelled: !1
+}), Y = (e, t, r = !1) => ({
+  value: e,
+  finished: t,
+  cancelled: r
+}), ge = (e) => ({
+  value: e,
+  cancelled: !0,
+  finished: !1
+});
+function mn(e, t, r, n) {
+  const { callId: s, parentId: a, onRest: o } = t, { asyncTo: l, promise: d } = r;
+  return !a && e === l && !t.reset ? d : r.promise = (async () => {
+    r.asyncId = s, r.asyncTo = e;
+    const u = Yt(
+      t,
+      (x, y) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        y === "onRest" ? void 0 : x
+      )
+    );
+    let m, p;
+    const v = new Promise(
+      (x, y) => (m = x, p = y)
+    ), g = (x) => {
+      const y = (
+        // The `cancel` prop or `stop` method was used.
+        s <= (r.cancelId || 0) && ge(n) || // The async `to` prop was replaced.
+        s !== r.asyncId && Y(n, !1)
+      );
+      if (y)
+        throw x.result = y, p(x), x;
+    }, _ = (x, y) => {
+      const b = new Fr(), S = new jr();
+      return (async () => {
+        if (G.skipAnimation)
+          throw Ne(r), S.result = Y(n, !1), p(S), S;
+        g(b);
+        const k = f.obj(x) ? { ...x } : { ...y, to: x };
+        k.parentId = s, K(u, (X, U) => {
+          f.und(k[U]) && (k[U] = X);
+        });
+        const j = await n.start(k);
+        return g(b), r.paused && await new Promise((X) => {
+          r.resumeQueue.add(X);
+        }), j;
+      })();
+    };
+    let R;
+    if (G.skipAnimation)
+      return Ne(r), Y(n, !1);
+    try {
+      let x;
+      f.arr(e) ? x = (async (y) => {
+        for (const b of y)
+          await _(b);
+      })(e) : x = Promise.resolve(e(_, n.stop.bind(n))), await Promise.all([x.then(m), v]), R = Y(n.get(), !0, !1);
+    } catch (x) {
+      if (x instanceof Fr)
+        R = x.result;
+      else if (x instanceof jr)
+        R = x.result;
+      else
+        throw x;
+    } finally {
+      s == r.asyncId && (r.asyncId = a, r.asyncTo = a ? l : void 0, r.promise = a ? d : void 0);
+    }
+    return f.fun(o) && E.batchedUpdates(() => {
+      o(R, n, n.item);
+    }), R;
+  })();
+}
+function Ne(e, t) {
+  Te(e.timeouts, (r) => r.cancel()), e.pauseQueue.clear(), e.resumeQueue.clear(), e.asyncId = e.asyncTo = e.promise = void 0, t && (e.cancelId = t);
+}
+var Fr = class extends Error {
+  constructor() {
+    super(
+      "An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise."
+    );
+  }
+}, jr = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+}, It = (e) => e instanceof Gt, rs = 1, Gt = class extends Zr {
+  constructor() {
+    super(...arguments), this.id = rs++, this._priority = 0;
+  }
+  get priority() {
+    return this._priority;
+  }
+  set priority(e) {
+    this._priority != e && (this._priority = e, this._onPriorityChange(e));
+  }
+  /** Get the current value */
+  get() {
+    const e = H(this);
+    return e && e.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...e) {
+    return G.to(this, e);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...e) {
+    return Ii(), G.to(this, e);
+  }
+  toJSON() {
+    return this.get();
+  }
+  observerAdded(e) {
+    e == 1 && this._attach();
+  }
+  observerRemoved(e) {
+    e == 0 && this._detach();
+  }
+  /** Called when the first child is added. */
+  _attach() {
+  }
+  /** Called when the last child is removed. */
+  _detach() {
+  }
+  /** Tell our children about our new value */
+  _onChange(e, t = !1) {
+    je(this, {
+      type: "change",
+      parent: this,
+      value: e,
+      idle: t
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(e) {
+    this.idle || st.sort(this), je(this, {
+      type: "priority",
+      parent: this,
+      priority: e
+    });
+  }
+}, fe = Symbol.for("SpringPhase"), pn = 1, vn = 2, gn = 4, St = (e) => (e[fe] & pn) > 0, ne = (e) => (e[fe] & vn) > 0, Ee = (e) => (e[fe] & gn) > 0, Vr = (e, t) => t ? e[fe] |= vn | pn : e[fe] &= -3, Dr = (e, t) => t ? e[fe] |= gn : e[fe] &= -5, ns = class extends Gt {
+  constructor(e, t) {
+    if (super(), this.animation = new ts(), this.defaultProps = {}, this._state = {
+      paused: !1,
+      delayed: !1,
+      pauseQueue: /* @__PURE__ */ new Set(),
+      resumeQueue: /* @__PURE__ */ new Set(),
+      timeouts: /* @__PURE__ */ new Set()
+    }, this._pendingCalls = /* @__PURE__ */ new Set(), this._lastCallId = 0, this._lastToId = 0, this._memoizedDuration = 0, !f.und(e) || !f.und(t)) {
+      const r = f.obj(e) ? { ...e } : { ...t, from: e };
+      f.und(r.default) && (r.default = !0), this.start(r);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(ne(this) || this._state.asyncTo) || Ee(this);
+  }
+  get goal() {
+    return q(this.animation.to);
+  }
+  get velocity() {
+    const e = H(this);
+    return e instanceof ze ? e.lastVelocity || 0 : e.getPayload().map((t) => t.lastVelocity || 0);
+  }
+  /**
+   * When true, this value has been animated at least once.
+   */
+  get hasAnimated() {
+    return St(this);
+  }
+  /**
+   * When true, this value has an unfinished animation,
+   * which is either active or paused.
+   */
+  get isAnimating() {
+    return ne(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return Ee(this);
+  }
+  /**
+   *
+   *
+   */
+  get isDelayed() {
+    return this._state.delayed;
+  }
+  /** Advance the current animation by a number of milliseconds */
+  advance(e) {
+    let t = !0, r = !1;
+    const n = this.animation;
+    let { toValues: s } = n;
+    const { config: a } = n, o = lt(n.to);
+    !o && W(n.to) && (s = L(q(n.to))), n.values.forEach((u, m) => {
+      if (u.done)
+        return;
+      const p = (
+        // Animated strings always go from 0 to 1.
+        u.constructor == $e ? 1 : o ? o[m].lastPosition : s[m]
+      );
+      let v = n.immediate, g = p;
+      if (!v) {
+        if (g = u.lastPosition, a.tension <= 0) {
+          u.done = !0;
+          return;
+        }
+        let _ = u.elapsedTime += e;
+        const R = n.fromValues[m], x = u.v0 != null ? u.v0 : u.v0 = f.arr(a.velocity) ? a.velocity[m] : a.velocity;
+        let y;
+        const b = a.precision || (R == p ? 5e-3 : Math.min(1, Math.abs(p - R) * 1e-3));
+        if (f.und(a.duration))
+          if (a.decay) {
+            const S = a.decay === !0 ? 0.998 : a.decay, k = Math.exp(-(1 - S) * _);
+            g = R + x / (1 - S) * (1 - k), v = Math.abs(u.lastPosition - g) <= b, y = x * k;
+          } else {
+            y = u.lastVelocity == null ? x : u.lastVelocity;
+            const S = a.restVelocity || b / 10, k = a.clamp ? 0 : a.bounce, j = !f.und(k), X = R == p ? u.v0 > 0 : R < p;
+            let U, de = !1;
+            const V = 1, oe = Math.ceil(e / V);
+            for (let M = 0; M < oe && (U = Math.abs(y) > S, !(!U && (v = Math.abs(p - g) <= b, v))); ++M) {
+              j && (de = g == p || g > p == X, de && (y = -y * k, g = p));
+              const Z = -a.tension * 1e-6 * (g - p), D = -a.friction * 1e-3 * y, ee = (Z + D) / a.mass;
+              y = y + ee * V, g = g + y * V;
+            }
+          }
+        else {
+          let S = 1;
+          a.duration > 0 && (this._memoizedDuration !== a.duration && (this._memoizedDuration = a.duration, u.durationProgress > 0 && (u.elapsedTime = a.duration * u.durationProgress, _ = u.elapsedTime += e)), S = (a.progress || 0) + _ / this._memoizedDuration, S = S > 1 ? 1 : S < 0 ? 0 : S, u.durationProgress = S), g = R + a.easing(S) * (p - R), y = (g - u.lastPosition) / e, v = S == 1;
+        }
+        u.lastVelocity = y, Number.isNaN(g) && (console.warn("Got NaN while animating:", this), v = !0);
+      }
+      o && !o[m].done && (v = !1), v ? u.done = !0 : t = !1, u.setValue(g, a.round) && (r = !0);
+    });
+    const l = H(this), d = l.getValue();
+    if (t) {
+      const u = q(n.to);
+      (d !== u || r) && !a.decay ? (l.setValue(u), this._onChange(u)) : r && a.decay && this._onChange(d), this._stop();
+    } else r && this._onChange(d);
+  }
+  /** Set the current value, while stopping the current animation */
+  set(e) {
+    return E.batchedUpdates(() => {
+      this._stop(), this._focus(e), this._set(e);
+    }), this;
+  }
+  /**
+   * Freeze the active animation in time, as well as any updates merged
+   * before `resume` is called.
+   */
+  pause() {
+    this._update({ pause: !0 });
+  }
+  /** Resume the animation if paused. */
+  resume() {
+    this._update({ pause: !1 });
+  }
+  /** Skip to the end of the current animation. */
+  finish() {
+    if (ne(this)) {
+      const { to: e, config: t } = this.animation;
+      E.batchedUpdates(() => {
+        this._onStart(), t.decay || this._set(e, !1), this._stop();
+      });
+    }
+    return this;
+  }
+  /** Push props into the pending queue. */
+  update(e) {
+    return (this.queue || (this.queue = [])).push(e), this;
+  }
+  start(e, t) {
+    let r;
+    return f.und(e) ? (r = this.queue || [], this.queue = []) : r = [f.obj(e) ? e : { ...t, to: e }], Promise.all(
+      r.map((n) => this._update(n))
+    ).then((n) => Qt(this, n));
+  }
+  /**
+   * Stop the current animation, and cancel any delayed updates.
+   *
+   * Pass `true` to call `onRest` with `cancelled: true`.
+   */
+  stop(e) {
+    const { to: t } = this.animation;
+    return this._focus(this.get()), Ne(this._state, e && this._lastCallId), E.batchedUpdates(() => this._stop(t, e)), this;
+  }
+  /** Restart the animation. */
+  reset() {
+    this._update({ reset: !0 });
+  }
+  /** @internal */
+  eventObserved(e) {
+    e.type == "change" ? this._start() : e.type == "priority" && (this.priority = e.priority + 1);
+  }
+  /**
+   * Parse the `to` and `from` range from the given `props` object.
+   *
+   * This also ensures the initial value is available to animated components
+   * during the render phase.
+   */
+  _prepareNode(e) {
+    const t = this.key || "";
+    let { to: r, from: n } = e;
+    r = f.obj(r) ? r[t] : r, (r == null || kt(r)) && (r = void 0), n = f.obj(n) ? n[t] : n, n == null && (n = void 0);
+    const s = { to: r, from: n };
+    return St(this) || (e.reverse && ([r, n] = [n, r]), n = q(n), f.und(n) ? H(this) || this._set(r) : this._set(n)), s;
+  }
+  /** Every update is processed by this method before merging. */
+  _update({ ...e }, t) {
+    const { key: r, defaultProps: n } = this;
+    e.default && Object.assign(
+      n,
+      Yt(
+        e,
+        (o, l) => /^on/.test(l) ? ln(o, r) : o
+      )
+    ), Ur(this, e, "onProps"), Pe(this, "onProps", e, this);
+    const s = this._prepareNode(e);
+    if (Object.isFrozen(this))
+      throw Error(
+        "Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?"
+      );
+    const a = this._state;
+    return dn(++this._lastCallId, {
+      key: r,
+      props: e,
+      defaultProps: n,
+      state: a,
+      actions: {
+        pause: () => {
+          Ee(this) || (Dr(this, !0), Ae(a.pauseQueue), Pe(
+            this,
+            "onPause",
+            Y(this, xe(this, this.animation.to)),
+            this
+          ));
+        },
+        resume: () => {
+          Ee(this) && (Dr(this, !1), ne(this) && this._resume(), Ae(a.resumeQueue), Pe(
+            this,
+            "onResume",
+            Y(this, xe(this, this.animation.to)),
+            this
+          ));
+        },
+        start: this._merge.bind(this, s)
+      }
+    }).then((o) => {
+      if (e.loop && o.finished && !(t && o.noop)) {
+        const l = yn(e);
+        if (l)
+          return this._update(l, !0);
+      }
+      return o;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(e, t, r) {
+    if (t.cancel)
+      return this.stop(!0), r(ge(this));
+    const n = !f.und(e.to), s = !f.und(e.from);
+    if (n || s)
+      if (t.callId > this._lastToId)
+        this._lastToId = t.callId;
+      else
+        return r(ge(this));
+    const { key: a, defaultProps: o, animation: l } = this, { to: d, from: u } = l;
+    let { to: m = d, from: p = u } = e;
+    s && !n && (!t.default || f.und(m)) && (m = p), t.reverse && ([m, p] = [p, m]);
+    const v = !te(p, u);
+    v && (l.from = p), p = q(p);
+    const g = !te(m, d);
+    g && this._focus(m);
+    const _ = kt(t.to), { config: R } = l, { decay: x, velocity: y } = R;
+    (n || s) && (R.velocity = 0), t.config && !_ && es(
+      R,
+      le(t.config, a),
+      // Avoid calling the same "config" prop twice.
+      t.config !== o.config ? le(o.config, a) : void 0
+    );
+    let b = H(this);
+    if (!b || f.und(m))
+      return r(Y(this, !0));
+    const S = (
+      // When `reset` is undefined, the `from` prop implies `reset: true`,
+      // except for declarative updates. When `reset` is defined, there
+      // must exist a value to animate from.
+      f.und(t.reset) ? s && !t.default : !f.und(p) && ke(t.reset, a)
+    ), k = S ? p : this.get(), j = Ue(m), X = f.num(j) || f.arr(j) || ut(j), U = !_ && (!X || ke(o.immediate || t.immediate, a));
+    if (g) {
+      const M = Ct(m);
+      if (M !== b.constructor)
+        if (U)
+          b = this._set(j);
+        else
+          throw Error(
+            `Cannot animate between ${b.constructor.name} and ${M.name}, as the "to" prop suggests`
+          );
+    }
+    const de = b.constructor;
+    let V = W(m), oe = !1;
+    if (!V) {
+      const M = S || !St(this) && v;
+      (g || M) && (oe = te(Ue(k), j), V = !oe), (!te(l.immediate, U) && !U || !te(R.decay, x) || !te(R.velocity, y)) && (V = !0);
+    }
+    if (oe && ne(this) && (l.changed && !S ? V = !0 : V || this._stop(d)), !_ && ((V || W(d)) && (l.values = b.getPayload(), l.toValues = W(m) ? null : de == $e ? [1] : L(j)), l.immediate != U && (l.immediate = U, !U && !S && this._set(d)), V)) {
+      const { onRest: M } = l;
+      A(ss, (D) => Ur(this, t, D));
+      const Z = Y(this, xe(this, d));
+      Ae(this._pendingCalls, Z), this._pendingCalls.add(r), l.changed && E.batchedUpdates(() => {
+        var D;
+        l.changed = !S, M == null || M(Z, this), S ? le(o.onRest, Z) : (D = l.onStart) == null || D.call(l, Z, this);
+      });
+    }
+    S && this._set(k), _ ? r(mn(t.to, t, this._state, this)) : V ? this._start() : ne(this) && !g ? this._pendingCalls.add(r) : r(hn(k));
+  }
+  /** Update the `animation.to` value, which might be a `FluidValue` */
+  _focus(e) {
+    const t = this.animation;
+    e !== t.to && (xr(this) && this._detach(), t.to = e, xr(this) && this._attach());
+  }
+  _attach() {
+    let e = 0;
+    const { to: t } = this.animation;
+    W(t) && (be(t, this), It(t) && (e = t.priority + 1)), this.priority = e;
+  }
+  _detach() {
+    const { to: e } = this.animation;
+    W(e) && Ve(e, this);
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(e, t = !0) {
+    const r = q(e);
+    if (!f.und(r)) {
+      const n = H(this);
+      if (!n || !te(r, n.getValue())) {
+        const s = Ct(r);
+        !n || n.constructor != s ? Bt(this, s.create(r)) : n.setValue(r), n && E.batchedUpdates(() => {
+          this._onChange(r, t);
+        });
+      }
+    }
+    return H(this);
+  }
+  _onStart() {
+    const e = this.animation;
+    e.changed || (e.changed = !0, Pe(
+      this,
+      "onStart",
+      Y(this, xe(this, e.to)),
+      this
+    ));
+  }
+  _onChange(e, t) {
+    t || (this._onStart(), le(this.animation.onChange, e, this)), le(this.defaultProps.onChange, e, this), super._onChange(e, t);
+  }
+  // This method resets the animation state (even if already animating) to
+  // ensure the latest from/to range is used, and it also ensures this spring
+  // is added to the frameloop.
+  _start() {
+    const e = this.animation;
+    H(this).reset(q(e.to)), e.immediate || (e.fromValues = e.values.map((t) => t.lastPosition)), ne(this) || (Vr(this, !0), Ee(this) || this._resume());
+  }
+  _resume() {
+    G.skipAnimation ? this.finish() : st.start(this);
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(e, t) {
+    if (ne(this)) {
+      Vr(this, !1);
+      const r = this.animation;
+      A(r.values, (s) => {
+        s.done = !0;
+      }), r.toValues && (r.onChange = r.onPause = r.onResume = void 0), je(this, {
+        type: "idle",
+        parent: this
+      });
+      const n = t ? ge(this.get()) : Y(this.get(), xe(this, e ?? r.to));
+      Ae(this._pendingCalls, n), r.changed && (r.changed = !1, Pe(this, "onRest", n, this));
+    }
+  }
+};
+function xe(e, t) {
+  const r = Ue(t), n = Ue(e.get());
+  return te(n, r);
+}
+function yn(e, t = e.loop, r = e.to) {
+  const n = le(t);
+  if (n) {
+    const s = n !== !0 && fn(n), a = (s || e).reverse, o = !s || s.reset;
+    return qe({
+      ...e,
+      loop: t,
+      // Avoid updating default props when looping.
+      default: !1,
+      // Never loop the `pause` prop.
+      pause: void 0,
+      // For the "reverse" prop to loop as expected, the "to" prop
+      // must be undefined. The "reverse" prop is ignored when the
+      // "to" prop is an array or function.
+      to: !a || kt(r) ? r : void 0,
+      // Ignore the "from" prop except on reset.
+      from: o ? e.from : void 0,
+      reset: o,
+      // The "loop" prop can return a "useSpring" props object to
+      // override any of the original props.
+      ...s
+    });
+  }
+}
+function qe(e) {
+  const { to: t, from: r } = e = fn(e), n = /* @__PURE__ */ new Set();
+  return f.obj(t) && $r(t, n), f.obj(r) && $r(r, n), e.keys = n.size ? Array.from(n) : null, e;
+}
+function is(e) {
+  const t = qe(e);
+  return f.und(t.default) && (t.default = Yt(t)), t;
+}
+function $r(e, t) {
+  K(e, (r, n) => r != null && t.add(n));
+}
+var ss = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function Ur(e, t, r) {
+  e.animation[r] = t[r] !== cn(t, r) ? ln(t[r], e.key) : void 0;
+}
+function Pe(e, t, ...r) {
+  var n, s, a, o;
+  (s = (n = e.animation)[t]) == null || s.call(n, ...r), (o = (a = e.defaultProps)[t]) == null || o.call(a, ...r);
+}
+var as = ["onStart", "onChange", "onRest"], os = 1, us = class {
+  constructor(e, t) {
+    this.id = os++, this.springs = {}, this.queue = [], this._lastAsyncId = 0, this._active = /* @__PURE__ */ new Set(), this._changed = /* @__PURE__ */ new Set(), this._started = !1, this._state = {
+      paused: !1,
+      pauseQueue: /* @__PURE__ */ new Set(),
+      resumeQueue: /* @__PURE__ */ new Set(),
+      timeouts: /* @__PURE__ */ new Set()
+    }, this._events = {
+      onStart: /* @__PURE__ */ new Map(),
+      onChange: /* @__PURE__ */ new Map(),
+      onRest: /* @__PURE__ */ new Map()
+    }, this._onFrame = this._onFrame.bind(this), t && (this._flush = t), e && this.start({ default: !0, ...e });
+  }
+  /**
+   * Equals `true` when no spring values are in the frameloop, and
+   * no async animation is currently active.
+   */
+  get idle() {
+    return !this._state.asyncTo && Object.values(this.springs).every((e) => e.idle && !e.isDelayed && !e.isPaused);
+  }
+  get item() {
+    return this._item;
+  }
+  set item(e) {
+    this._item = e;
+  }
+  /** Get the current values of our springs */
+  get() {
+    const e = {};
+    return this.each((t, r) => e[r] = t.get()), e;
+  }
+  /** Set the current values without animating. */
+  set(e) {
+    for (const t in e) {
+      const r = e[t];
+      f.und(r) || this.springs[t].set(r);
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(e) {
+    return e && this.queue.push(qe(e)), this;
+  }
+  /**
+   * Start the queued animations for every spring, and resolve the returned
+   * promise once all queued animations have finished or been cancelled.
+   *
+   * When you pass a queue (instead of nothing), that queue is used instead of
+   * the queued animations added with the `update` method, which are left alone.
+   */
+  start(e) {
+    let { queue: t } = this;
+    return e ? t = L(e).map(qe) : this.queue = [], this._flush ? this._flush(this, t) : (Sn(this, t), Ft(this, t));
+  }
+  /** @internal */
+  stop(e, t) {
+    if (e !== !!e && (t = e), t) {
+      const r = this.springs;
+      A(L(t), (n) => r[n].stop(!!e));
+    } else
+      Ne(this._state, this._lastAsyncId), this.each((r) => r.stop(!!e));
+    return this;
+  }
+  /** Freeze the active animation in time */
+  pause(e) {
+    if (f.und(e))
+      this.start({ pause: !0 });
+    else {
+      const t = this.springs;
+      A(L(e), (r) => t[r].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(e) {
+    if (f.und(e))
+      this.start({ pause: !1 });
+    else {
+      const t = this.springs;
+      A(L(e), (r) => t[r].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(e) {
+    K(this.springs, e);
+  }
+  /** @internal Called at the end of every animation frame */
+  _onFrame() {
+    const { onStart: e, onChange: t, onRest: r } = this._events, n = this._active.size > 0, s = this._changed.size > 0;
+    (n && !this._started || s && !this._started) && (this._started = !0, Te(e, ([l, d]) => {
+      d.value = this.get(), l(d, this, this._item);
+    }));
+    const a = !n && this._started, o = s || a && r.size ? this.get() : null;
+    s && t.size && Te(t, ([l, d]) => {
+      d.value = o, l(d, this, this._item);
+    }), a && (this._started = !1, Te(r, ([l, d]) => {
+      d.value = o, l(d, this, this._item);
+    }));
+  }
+  /** @internal */
+  eventObserved(e) {
+    if (e.type == "change")
+      this._changed.add(e.parent), e.idle || this._active.add(e.parent);
+    else if (e.type == "idle")
+      this._active.delete(e.parent);
+    else
+      return;
+    E.onFrame(this._onFrame);
+  }
+};
+function Ft(e, t) {
+  return Promise.all(t.map((r) => bn(e, r))).then(
+    (r) => Qt(e, r)
+  );
+}
+async function bn(e, t, r) {
+  const { keys: n, to: s, from: a, loop: o, onRest: l, onResolve: d } = t, u = f.obj(t.default) && t.default;
+  o && (t.loop = !1), s === !1 && (t.to = null), a === !1 && (t.from = null);
+  const m = f.arr(s) || f.fun(s) ? s : void 0;
+  m ? (t.to = void 0, t.onRest = void 0, u && (u.onRest = void 0)) : A(as, (R) => {
+    const x = t[R];
+    if (f.fun(x)) {
+      const y = e._events[R];
+      t[R] = ({ finished: b, cancelled: S }) => {
+        const k = y.get(x);
+        k ? (b || (k.finished = !1), S && (k.cancelled = !0)) : y.set(x, {
+          value: null,
+          finished: b || !1,
+          cancelled: S || !1
+        });
+      }, u && (u[R] = t[R]);
+    }
+  });
+  const p = e._state;
+  t.pause === !p.paused ? (p.paused = t.pause, Ae(t.pause ? p.pauseQueue : p.resumeQueue)) : p.paused && (t.pause = !0);
+  const v = (n || Object.keys(e.springs)).map(
+    (R) => e.springs[R].start(t)
+  ), g = t.cancel === !0 || cn(t, "cancel") === !0;
+  (m || g && p.asyncId) && v.push(
+    dn(++e._lastAsyncId, {
+      props: t,
+      state: p,
+      actions: {
+        pause: At,
+        resume: At,
+        start(R, x) {
+          g ? (Ne(p, e._lastAsyncId), x(ge(e))) : (R.onRest = l, x(
+            mn(
+              m,
+              R,
+              p,
+              e
+            )
+          ));
+        }
+      }
+    })
+  ), p.paused && await new Promise((R) => {
+    p.resumeQueue.add(R);
+  });
+  const _ = Qt(e, await Promise.all(v));
+  if (o && _.finished && !(r && _.noop)) {
+    const R = yn(t, o, s);
+    if (R)
+      return Sn(e, [R]), bn(e, R, !0);
+  }
+  return d && E.batchedUpdates(() => d(_, e, e.item)), _;
+}
+function Nr(e, t) {
+  const r = { ...e.springs };
+  return t && A(L(t), (n) => {
+    f.und(n.keys) && (n = qe(n)), f.obj(n.to) || (n = { ...n, to: void 0 }), Rn(r, n, (s) => wn(s));
+  }), _n(e, r), r;
+}
+function _n(e, t) {
+  K(t, (r, n) => {
+    e.springs[n] || (e.springs[n] = r, be(r, e));
+  });
+}
+function wn(e, t) {
+  const r = new ns();
+  return r.key = e, t && be(r, t), r;
+}
+function Rn(e, t, r) {
+  t.keys && A(t.keys, (n) => {
+    (e[n] || (e[n] = r(n)))._prepareNode(t);
+  });
+}
+function Sn(e, t) {
+  A(t, (r) => {
+    Rn(e.springs, r, (n) => wn(n, e));
+  });
+}
+var ft = ({
+  children: e,
+  ...t
+}) => {
+  const r = zr(nt), n = t.pause || !!r.pause, s = t.immediate || !!r.immediate;
+  t = Di(() => ({ pause: n, immediate: s }), [n, s]);
+  const { Provider: a } = nt;
+  return /* @__PURE__ */ jt.createElement(a, { value: t }, e);
+}, nt = ls(ft, {});
+ft.Provider = nt.Provider;
+ft.Consumer = nt.Consumer;
+function ls(e, t) {
+  return Object.assign(e, jt.createContext(t)), e.Provider._context = e, e.Consumer._context = e, e;
+}
+var cs = () => {
+  const e = [], t = function(n) {
+    ji();
+    const s = [];
+    return A(e, (a, o) => {
+      if (f.und(n))
+        s.push(a.start());
+      else {
+        const l = r(n, a, o);
+        l && s.push(a.start(l));
+      }
+    }), s;
+  };
+  t.current = e, t.add = function(n) {
+    e.includes(n) || e.push(n);
+  }, t.delete = function(n) {
+    const s = e.indexOf(n);
+    ~s && e.splice(s, 1);
+  }, t.pause = function() {
+    return A(e, (n) => n.pause(...arguments)), this;
+  }, t.resume = function() {
+    return A(e, (n) => n.resume(...arguments)), this;
+  }, t.set = function(n) {
+    A(e, (s, a) => {
+      const o = f.fun(n) ? n(a, s) : n;
+      o && s.set(o);
+    });
+  }, t.start = function(n) {
+    const s = [];
+    return A(e, (a, o) => {
+      if (f.und(n))
+        s.push(a.start());
+      else {
+        const l = this._getProps(n, a, o);
+        l && s.push(a.start(l));
+      }
+    }), s;
+  }, t.stop = function() {
+    return A(e, (n) => n.stop(...arguments)), this;
+  }, t.update = function(n) {
+    return A(e, (s, a) => s.update(this._getProps(n, s, a))), this;
+  };
+  const r = function(n, s, a) {
+    return f.fun(n) ? n(a, s) : n;
+  };
+  return t._getProps = r, t;
+};
+function fs(e, t, r) {
+  const n = f.fun(t) && t;
+  n && !r && (r = []);
+  const s = Ge(
+    () => n || arguments.length == 3 ? cs() : void 0,
+    []
+  ), a = re(0), o = sn(), l = Ge(
+    () => ({
+      ctrls: [],
+      queue: [],
+      flush(y, b) {
+        const S = Nr(y, b);
+        return a.current > 0 && !l.queue.length && !Object.keys(S).some((j) => !y.springs[j]) ? Ft(y, b) : new Promise((j) => {
+          _n(y, S), l.queue.push(() => {
+            j(Ft(y, b));
+          }), o();
+        });
+      }
+    }),
+    []
+  ), d = re([...l.ctrls]), u = [], m = Ar(e) || 0;
+  Ge(() => {
+    A(d.current.slice(e, m), (y) => {
+      Ji(y, s), y.stop(!0);
+    }), d.current.length = e, p(m, e);
+  }, [e]), Ge(() => {
+    p(0, Math.min(m, e));
+  }, r);
+  function p(y, b) {
+    for (let S = y; S < b; S++) {
+      const k = d.current[S] || (d.current[S] = new us(null, l.flush)), j = n ? n(S, k) : t[S];
+      j && (u[S] = is(j));
+    }
+  }
+  const v = d.current.map((y, b) => Nr(y, u[b])), g = zr(ft), _ = Ar(g), R = g !== _ && Hi(g);
+  Wt(() => {
+    a.current++, l.ctrls = d.current;
+    const { queue: y } = l;
+    y.length && (l.queue = [], A(y, (b) => b())), A(d.current, (b, S) => {
+      s == null || s.add(b), R && b.start({ default: g });
+      const k = u[S];
+      k && (Ki(b, k.ref), b.ref ? b.queue.push(k) : b.start(k));
+    });
+  }), an(() => () => {
+    A(l.ctrls, (y) => y.stop(!0));
+  });
+  const x = v.map((y) => ({ ...y }));
+  return s ? [x, s] : x;
+}
+function ds(e, t) {
+  const r = f.fun(e), [[n], s] = fs(
+    1,
+    r ? e : [e],
+    r ? [] : t
+  );
+  return r || arguments.length == 2 ? [n, s] : n;
+}
+var hs = class extends Gt {
+  constructor(e, t) {
+    super(), this.source = e, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = Ie(...t);
+    const r = this._get(), n = Ct(r);
+    Bt(this, n.create(r));
+  }
+  advance(e) {
+    const t = this._get(), r = this.get();
+    te(t, r) || (H(this).setValue(t), this._onChange(t, this.idle)), !this.idle && qr(this._active) && Et(this);
+  }
+  _get() {
+    const e = f.arr(this.source) ? this.source.map(q) : L(q(this.source));
+    return this.calc(...e);
+  }
+  _start() {
+    this.idle && !qr(this._active) && (this.idle = !1, A(lt(this), (e) => {
+      e.done = !1;
+    }), G.skipAnimation ? (E.batchedUpdates(() => this.advance()), Et(this)) : st.start(this));
+  }
+  // Observe our sources only when we're observed.
+  _attach() {
+    let e = 1;
+    A(L(this.source), (t) => {
+      W(t) && be(t, this), It(t) && (t.idle || this._active.add(t), e = Math.max(e, t.priority + 1));
+    }), this.priority = e, this._start();
+  }
+  // Stop observing our sources once we have no observers.
+  _detach() {
+    A(L(this.source), (e) => {
+      W(e) && Ve(e, this);
+    }), this._active.clear(), Et(this);
+  }
+  /** @internal */
+  eventObserved(e) {
+    e.type == "change" ? e.idle ? this.advance() : (this._active.add(e.parent), this._start()) : e.type == "idle" ? this._active.delete(e.parent) : e.type == "priority" && (this.priority = L(this.source).reduce(
+      (t, r) => Math.max(t, (It(r) ? r.priority : 0) + 1),
+      0
+    ));
+  }
+};
+function ms(e) {
+  return e.idle !== !1;
+}
+function qr(e) {
+  return !e.size || Array.from(e).every(ms);
+}
+function Et(e) {
+  e.idle || (e.idle = !0, A(lt(e), (t) => {
+    t.done = !0;
+  }), je(e, {
+    type: "idle",
+    parent: e
+  }));
+}
+G.assign({
+  createStringInterpolator: rn,
+  to: (e, t) => new hs(e, t)
+});
+var En = /^--/;
+function ps(e, t) {
+  return t == null || typeof t == "boolean" || t === "" ? "" : typeof t == "number" && t !== 0 && !En.test(e) && !(Oe.hasOwnProperty(e) && Oe[e]) ? t + "px" : ("" + t).trim();
+}
+var Mr = {};
+function vs(e, t) {
+  if (!e.nodeType || !e.setAttribute)
+    return !1;
+  const r = e.nodeName === "filter" || e.parentNode && e.parentNode.nodeName === "filter", {
+    className: n,
+    style: s,
+    children: a,
+    scrollTop: o,
+    scrollLeft: l,
+    viewBox: d,
+    ...u
+  } = t, m = Object.values(u), p = Object.keys(u).map(
+    (v) => r || e.hasAttribute(v) ? v : Mr[v] || (Mr[v] = v.replace(
+      /([A-Z])/g,
+      // Attributes are written in dash case
+      (g) => "-" + g.toLowerCase()
+    ))
+  );
+  a !== void 0 && (e.textContent = a);
+  for (const v in s)
+    if (s.hasOwnProperty(v)) {
+      const g = ps(v, s[v]);
+      En.test(v) ? e.style.setProperty(v, g) : e.style[v] = g;
+    }
+  p.forEach((v, g) => {
+    e.setAttribute(v, m[g]);
+  }), n !== void 0 && (e.className = n), o !== void 0 && (e.scrollTop = o), l !== void 0 && (e.scrollLeft = l), d !== void 0 && e.setAttribute("viewBox", d);
+}
+var Oe = {
+  animationIterationCount: !0,
+  borderImageOutset: !0,
+  borderImageSlice: !0,
+  borderImageWidth: !0,
+  boxFlex: !0,
+  boxFlexGroup: !0,
+  boxOrdinalGroup: !0,
+  columnCount: !0,
+  columns: !0,
+  flex: !0,
+  flexGrow: !0,
+  flexPositive: !0,
+  flexShrink: !0,
+  flexNegative: !0,
+  flexOrder: !0,
+  gridRow: !0,
+  gridRowEnd: !0,
+  gridRowSpan: !0,
+  gridRowStart: !0,
+  gridColumn: !0,
+  gridColumnEnd: !0,
+  gridColumnSpan: !0,
+  gridColumnStart: !0,
+  fontWeight: !0,
+  lineClamp: !0,
+  lineHeight: !0,
+  opacity: !0,
+  order: !0,
+  orphans: !0,
+  tabSize: !0,
+  widows: !0,
+  zIndex: !0,
+  zoom: !0,
+  // SVG-related properties
+  fillOpacity: !0,
+  floodOpacity: !0,
+  stopOpacity: !0,
+  strokeDasharray: !0,
+  strokeDashoffset: !0,
+  strokeMiterlimit: !0,
+  strokeOpacity: !0,
+  strokeWidth: !0
+}, gs = (e, t) => e + t.charAt(0).toUpperCase() + t.substring(1), ys = ["Webkit", "Ms", "Moz", "O"];
+Oe = Object.keys(Oe).reduce((e, t) => (ys.forEach((r) => e[gs(r, t)] = e[t]), e), Oe);
+var bs = /^(matrix|translate|scale|rotate|skew)/, _s = /^(translate)/, ws = /^(rotate|skew)/, xt = (e, t) => f.num(e) && e !== 0 ? e + t : e, Xe = (e, t) => f.arr(e) ? e.every((r) => Xe(r, t)) : f.num(e) ? e === t : parseFloat(e) === t, Rs = class extends ct {
+  constructor({ x: e, y: t, z: r, ...n }) {
+    const s = [], a = [];
+    (e || t || r) && (s.push([e || 0, t || 0, r || 0]), a.push((o) => [
+      `translate3d(${o.map((l) => xt(l, "px")).join(",")})`,
+      // prettier-ignore
+      Xe(o, 0)
+    ])), K(n, (o, l) => {
+      if (l === "transform")
+        s.push([o || ""]), a.push((d) => [d, d === ""]);
+      else if (bs.test(l)) {
+        if (delete n[l], f.und(o))
+          return;
+        const d = _s.test(l) ? "px" : ws.test(l) ? "deg" : "";
+        s.push(L(o)), a.push(
+          l === "rotate3d" ? ([u, m, p, v]) => [
+            `rotate3d(${u},${m},${p},${xt(v, d)})`,
+            Xe(v, 0)
+          ] : (u) => [
+            `${l}(${u.map((m) => xt(m, d)).join(",")})`,
+            Xe(u, l.startsWith("scale") ? 1 : 0)
+          ]
+        );
+      }
+    }), s.length && (n.transform = new Ss(s, a)), super(n);
+  }
+}, Ss = class extends Zr {
+  constructor(e, t) {
+    super(), this.inputs = e, this.transforms = t, this._value = null;
+  }
+  get() {
+    return this._value || (this._value = this._get());
+  }
+  _get() {
+    let e = "", t = !0;
+    return A(this.inputs, (r, n) => {
+      const s = q(r[0]), [a, o] = this.transforms[n](
+        f.arr(s) ? s : r.map(q)
+      );
+      e += " " + a, t = t && o;
+    }), t ? "none" : e;
+  }
+  // Start observing our inputs once we have an observer.
+  observerAdded(e) {
+    e == 1 && A(
+      this.inputs,
+      (t) => A(
+        t,
+        (r) => W(r) && be(r, this)
+      )
+    );
+  }
+  // Stop observing our inputs once we have no observers.
+  observerRemoved(e) {
+    e == 0 && A(
+      this.inputs,
+      (t) => A(
+        t,
+        (r) => W(r) && Ve(r, this)
+      )
+    );
+  }
+  eventObserved(e) {
+    e.type == "change" && (this._value = null), je(this, e);
+  }
+}, Es = [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "big",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "keygen",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr",
+  // SVG
+  "circle",
+  "clipPath",
+  "defs",
+  "ellipse",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "mask",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "stop",
+  "svg",
+  "text",
+  "tspan"
+];
+G.assign({
+  batchedUpdates: ti,
+  createStringInterpolator: rn,
+  colors: di
+});
+var xs = Wi(Es, {
+  applyAnimatedValues: vs,
+  createAnimatedStyle: (e) => new Rs(e),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getComponentProps: ({ scrollTop: e, scrollLeft: t, ...r }) => r
+}), Ps = xs.animated;
+function As(e) {
+  const t = e.htmlElement ?? "div", [r, n] = Ze(!1), s = re(null), a = re(null), [o, l] = Ze(null), [d, u] = ds(() => ({
+    from: {
+      opacity: 0,
+      transform: "scale(0)"
+    },
+    to: {
+      opacity: 1,
+      transform: "scale(1)"
+    }
+  })), m = (g, _) => Math.floor(Math.random() * (_ - g + 1)) + g;
+  ce(() => {
+    if (s.current && a.current) {
+      const g = s.current.getBoundingClientRect(), _ = a.current.getBoundingClientRect(), R = Math.max(g.height, _.height);
+      l(R);
+    }
+  }, []), ce(() => {
+    if (!e.animate) return;
+    const g = setTimeout(() => {
+      u({
+        opacity: 0,
+        transform: "translateY(15px)",
+        config: { duration: 200 },
+        onRest: () => {
+          n((_) => !_), u({
+            opacity: 1,
+            transform: "translateY(0px)",
+            config: { duration: 200 }
+          });
+        }
+      });
+    }, m(3500, 15e3));
+    return () => clearTimeout(g);
+  }, [r, e.animate, u]);
+  const p = e.animate && r ? e.content.simplified : e.content.english, v = {
+    ...e.textStyles,
+    minHeight: o !== null ? `${o}px` : void 0,
+    display: "inline-block",
+    // helps keep the bounding box stable,
+    alignContent: "center"
+  };
+  return /* @__PURE__ */ J.jsxs(J.Fragment, { children: [
+    /* @__PURE__ */ J.jsx(
+      "div",
+      {
+        ref: s,
+        style: {
+          position: "absolute",
+          visibility: "hidden",
+          pointerEvents: "none",
+          whiteSpace: "nowrap",
+          // Keep text on one line if needed, or remove if multiline
+          font: "inherit"
+          // Inherit font styling to get accurate measurement
+        },
+        children: e.content.english
+      }
+    ),
+    /* @__PURE__ */ J.jsx(
+      "div",
+      {
+        ref: a,
+        style: {
+          position: "absolute",
+          visibility: "hidden",
+          pointerEvents: "none",
+          whiteSpace: "nowrap",
+          font: "inherit"
+        },
+        children: e.content.simplified
+      }
+    ),
+    /* @__PURE__ */ J.jsx(Ps.div, { style: d, children: /* @__PURE__ */ J.jsx(t, { style: v, children: p }) })
+  ] });
+}
+const ks = ({
+  IconComponent: e,
+  buttonText: t,
+  buttonType: r = "primary"
+}) => {
+  const n = r === "primary" ? "primary" : "secondary";
+  return /* @__PURE__ */ J.jsx("div", { className: "banner-button-container", children: /* @__PURE__ */ J.jsxs("button", { className: `banner-button ${n}`, children: [
+    e && /* @__PURE__ */ J.jsx(e, { className: "icon-component" }),
+    /* @__PURE__ */ J.jsx(As, { textStyles: { minWidth: "3rem" }, content: t, animate: !0 })
+  ] }) });
+};
+export {
+  As as AnimatedText,
+  ks as BannerButton
+};