@micjanic/recursive-grid 1.0.4 → 1.0.6

package/dist/recursive-grid.es.js

@@ -1,5 +1,2621 @@
-import { ap as f } from "./PixiApp-BHmY2ZMg.js";
+var Jr = Object.defineProperty;
+var Xr = (e, t, r) => t in e ? Jr(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var B = (e, t, r) => Xr(e, typeof t != "symbol" ? t + "" : t, r);
+import * as cr from "react";
+import Zr, { useEffect as Te, useLayoutEffect as Kr, useState as Fe, useRef as W, forwardRef as en, useCallback as tn, useMemo as me, useContext as dr, createContext as rn } from "react";
+import { useApplication as nn, useTick as sn, extend as an, Application as on } from "@pixi/react";
+import { Graphics as fr, Particle as hr, Sprite as un, Container as ln, Texture as cn, ParticleContainer as dn } from "pixi.js";
+import { unstable_batchedUpdates as fn } from "react-dom";
+var Oe = { exports: {} }, le = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ft;
+function hn() {
+  if (Ft) return le;
+  Ft = 1;
+  var e = Symbol.for("react.transitional.element"), t = Symbol.for("react.fragment");
+  function r(n, s, i) {
+    var a = null;
+    if (i !== void 0 && (a = "" + i), s.key !== void 0 && (a = "" + s.key), "key" in s) {
+      i = {};
+      for (var u in s)
+        u !== "key" && (i[u] = s[u]);
+    } else i = s;
+    return s = i.ref, {
+      $$typeof: e,
+      type: n,
+      key: a,
+      ref: s !== void 0 ? s : null,
+      props: i
+    };
+  }
+  return le.Fragment = t, le.jsx = r, le.jsxs = r, le;
+}
+var ce = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Vt;
+function mn() {
+  return Vt || (Vt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(o) {
+      if (o == null) return null;
+      if (typeof o == "function")
+        return o.$$typeof === j ? null : o.displayName || o.name || null;
+      if (typeof o == "string") return o;
+      switch (o) {
+        case w:
+          return "Fragment";
+        case R:
+          return "Profiler";
+        case g:
+          return "StrictMode";
+        case Q:
+          return "Suspense";
+        case I:
+          return "SuspenseList";
+        case K:
+          return "Activity";
+      }
+      if (typeof o == "object")
+        switch (typeof o.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), o.$$typeof) {
+          case v:
+            return "Portal";
+          case A:
+            return o.displayName || "Context";
+          case y:
+            return (o._context.displayName || "Context") + ".Consumer";
+          case P:
+            var S = o.render;
+            return o = o.displayName, o || (o = S.displayName || S.name || "", o = o !== "" ? "ForwardRef(" + o + ")" : "ForwardRef"), o;
+          case re:
+            return S = o.displayName || null, S !== null ? S : e(o.type) || "Memo";
+          case C:
+            S = o._payload, o = o._init;
+            try {
+              return e(o(S));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function t(o) {
+      return "" + o;
+    }
+    function r(o) {
+      try {
+        t(o);
+        var S = !1;
+      } catch {
+        S = !0;
+      }
+      if (S) {
+        S = console;
+        var E = S.error, T = typeof Symbol == "function" && Symbol.toStringTag && o[Symbol.toStringTag] || o.constructor.name || "Object";
+        return E.call(
+          S,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          T
+        ), t(o);
+      }
+    }
+    function n(o) {
+      if (o === w) return "<>";
+      if (typeof o == "object" && o !== null && o.$$typeof === C)
+        return "<...>";
+      try {
+        var S = e(o);
+        return S ? "<" + S + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function s() {
+      var o = M.A;
+      return o === null ? null : o.getOwner();
+    }
+    function i() {
+      return Error("react-stack-top-frame");
+    }
+    function a(o) {
+      if (G.call(o, "key")) {
+        var S = Object.getOwnPropertyDescriptor(o, "key").get;
+        if (S && S.isReactWarning) return !1;
+      }
+      return o.key !== void 0;
+    }
+    function u(o, S) {
+      function E() {
+        kt || (kt = !0, console.error(
+          "%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://react.dev/link/special-props)",
+          S
+        ));
+      }
+      E.isReactWarning = !0, Object.defineProperty(o, "key", {
+        get: E,
+        configurable: !0
+      });
+    }
+    function d() {
+      var o = e(this.type);
+      return Ct[o] || (Ct[o] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), o = this.props.ref, o !== void 0 ? o : null;
+    }
+    function l(o, S, E, T, Ie, Xe) {
+      var k = E.ref;
+      return o = {
+        $$typeof: _,
+        type: o,
+        key: S,
+        props: E,
+        _owner: T
+      }, (k !== void 0 ? k : null) !== null ? Object.defineProperty(o, "ref", {
+        enumerable: !1,
+        get: d
+      }) : Object.defineProperty(o, "ref", { enumerable: !1, value: null }), o._store = {}, Object.defineProperty(o._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(o, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(o, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Ie
+      }), Object.defineProperty(o, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Xe
+      }), Object.freeze && (Object.freeze(o.props), Object.freeze(o)), o;
+    }
+    function m(o, S, E, T, Ie, Xe) {
+      var k = S.children;
+      if (k !== void 0)
+        if (T)
+          if (He(k)) {
+            for (T = 0; T < k.length; T++)
+              f(k[T]);
+            Object.freeze && Object.freeze(k);
+          } else
+            console.error(
+              "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 f(k);
+      if (G.call(S, "key")) {
+        k = e(o);
+        var ne = Object.keys(S).filter(function(Hr) {
+          return Hr !== "key";
+        });
+        T = 0 < ne.length ? "{key: someKey, " + ne.join(": ..., ") + ": ...}" : "{key: someKey}", jt[k + T] || (ne = 0 < ne.length ? "{" + ne.join(": ..., ") + ": ...}" : "{}", console.error(
+          `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} />`,
+          T,
+          k,
+          ne,
+          k
+        ), jt[k + T] = !0);
+      }
+      if (k = null, E !== void 0 && (r(E), k = "" + E), a(S) && (r(S.key), k = "" + S.key), "key" in S) {
+        E = {};
+        for (var Ze in S)
+          Ze !== "key" && (E[Ze] = S[Ze]);
+      } else E = S;
+      return k && u(
+        E,
+        typeof o == "function" ? o.displayName || o.name || "Unknown" : o
+      ), l(
+        o,
+        k,
+        E,
+        s(),
+        Ie,
+        Xe
+      );
+    }
+    function f(o) {
+      h(o) ? o._store && (o._store.validated = 1) : typeof o == "object" && o !== null && o.$$typeof === C && (o._payload.status === "fulfilled" ? h(o._payload.value) && o._payload.value._store && (o._payload.value._store.validated = 1) : o._store && (o._store.validated = 1));
+    }
+    function h(o) {
+      return typeof o == "object" && o !== null && o.$$typeof === _;
+    }
+    var p = Zr, _ = Symbol.for("react.transitional.element"), v = Symbol.for("react.portal"), w = Symbol.for("react.fragment"), g = Symbol.for("react.strict_mode"), R = Symbol.for("react.profiler"), y = Symbol.for("react.consumer"), A = Symbol.for("react.context"), P = Symbol.for("react.forward_ref"), Q = Symbol.for("react.suspense"), I = Symbol.for("react.suspense_list"), re = Symbol.for("react.memo"), C = Symbol.for("react.lazy"), K = Symbol.for("react.activity"), j = Symbol.for("react.client.reference"), M = p.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, G = Object.prototype.hasOwnProperty, He = Array.isArray, Je = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    p = {
+      react_stack_bottom_frame: function(o) {
+        return o();
+      }
+    };
+    var kt, Ct = {}, It = p.react_stack_bottom_frame.bind(
+      p,
+      i
+    )(), Ot = Je(n(i)), jt = {};
+    ce.Fragment = w, ce.jsx = function(o, S, E) {
+      var T = 1e4 > M.recentlyCreatedOwnerStacks++;
+      return m(
+        o,
+        S,
+        E,
+        !1,
+        T ? Error("react-stack-top-frame") : It,
+        T ? Je(n(o)) : Ot
+      );
+    }, ce.jsxs = function(o, S, E) {
+      var T = 1e4 > M.recentlyCreatedOwnerStacks++;
+      return m(
+        o,
+        S,
+        E,
+        !0,
+        T ? Error("react-stack-top-frame") : It,
+        T ? Je(n(o)) : Ot
+      );
+    };
+  })()), ce;
+}
+var Nt;
+function pn() {
+  return Nt || (Nt = 1, process.env.NODE_ENV === "production" ? Oe.exports = hn() : Oe.exports = mn()), Oe.exports;
+}
+var D = pn(), pt = Ce(), b = (e) => ke(e, pt), gt = Ce();
+b.write = (e) => ke(e, gt);
+var Me = Ce();
+b.onStart = (e) => ke(e, Me);
+var vt = Ce();
+b.onFrame = (e) => ke(e, vt);
+var yt = Ce();
+b.onFinish = (e) => ke(e, yt);
+var ie = [];
+b.setTimeout = (e, t) => {
+  const r = b.now() + t, n = () => {
+    const i = ie.findIndex((a) => a.cancel == n);
+    ~i && ie.splice(i, 1), X -= ~i ? 1 : 0;
+  }, s = { time: r, handler: e, cancel: n };
+  return ie.splice(mr(r), 0, s), X += 1, pr(), s;
+};
+var mr = (e) => ~(~ie.findIndex((t) => t.time > e) || ~ie.length);
+b.cancel = (e) => {
+  Me.delete(e), vt.delete(e), yt.delete(e), pt.delete(e), gt.delete(e);
+};
+b.sync = (e) => {
+  it = !0, b.batchedUpdates(e), it = !1;
+};
+b.throttle = (e) => {
+  let t;
+  function r() {
+    try {
+      e(...t);
+    } finally {
+      t = null;
+    }
+  }
+  function n(...s) {
+    t = s, b.onStart(r);
+  }
+  return n.handler = e, n.cancel = () => {
+    Me.delete(r), t = null;
+  }, n;
+};
+var _t = typeof window < "u" ? window.requestAnimationFrame : (
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  (() => {
+  })
+);
+b.use = (e) => _t = e;
+b.now = typeof performance < "u" ? () => performance.now() : Date.now;
+b.batchedUpdates = (e) => e();
+b.catch = console.error;
+b.frameLoop = "always";
+b.advance = () => {
+  b.frameLoop !== "demand" ? console.warn(
+    "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"
+  ) : vr();
+};
+var J = -1, X = 0, it = !1;
+function ke(e, t) {
+  it ? (t.delete(e), e(0)) : (t.add(e), pr());
+}
+function pr() {
+  J < 0 && (J = 0, b.frameLoop !== "demand" && _t(gr));
+}
+function gn() {
+  J = -1;
+}
+function gr() {
+  ~J && (_t(gr), b.batchedUpdates(vr));
+}
+function vr() {
+  const e = J;
+  J = b.now();
+  const t = mr(J);
+  if (t && (yr(ie.splice(0, t), (r) => r.handler()), X -= t), !X) {
+    gn();
+    return;
+  }
+  Me.flush(), pt.flush(e ? Math.min(64, J - e) : 16.667), vt.flush(), gt.flush(), yt.flush();
+}
+function Ce() {
+  let e = /* @__PURE__ */ new Set(), t = e;
+  return {
+    add(r) {
+      X += t == e && !e.has(r) ? 1 : 0, e.add(r);
+    },
+    delete(r) {
+      return X -= t == e && e.has(r) ? 1 : 0, e.delete(r);
+    },
+    flush(r) {
+      t.size && (e = /* @__PURE__ */ new Set(), X -= t.size, yr(t, (n) => n(r) && e.add(n)), X += e.size, t = e);
+    }
+  };
+}
+function yr(e, t) {
+  e.forEach((r) => {
+    try {
+      t(r);
+    } catch (n) {
+      b.catch(n);
+    }
+  });
+}
+var vn = Object.defineProperty, yn = (e, t) => {
+  for (var r in t)
+    vn(e, r, { get: t[r], enumerable: !0 });
+}, q = {};
+yn(q, {
+  assign: () => bn,
+  colors: () => Z,
+  createStringInterpolator: () => wt,
+  skipAnimation: () => br,
+  to: () => _r,
+  willAdvance: () => Rt
+});
+function at() {
+}
+var _n = (e, t, r) => Object.defineProperty(e, t, { value: r, writable: !0, configurable: !0 }), c = {
+  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 Y(e, t) {
+  if (c.arr(e)) {
+    if (!c.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 x = (e, t) => e.forEach(t);
+function L(e, t, r) {
+  if (c.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 F = (e) => c.und(e) ? [] : c.arr(e) ? e : [e];
+function ge(e, t) {
+  if (e.size) {
+    const r = Array.from(e);
+    e.clear(), x(r, t);
+  }
+}
+var pe = (e, ...t) => ge(e, (r) => r(...t)), bt = () => typeof window > "u" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent), wt, _r, Z = null, br = !1, Rt = at, bn = (e) => {
+  e.to && (_r = e.to), e.now && (b.now = e.now), e.colors !== void 0 && (Z = e.colors), e.skipAnimation != null && (br = e.skipAnimation), e.createStringInterpolator && (wt = e.createStringInterpolator), e.requestAnimationFrame && b.use(e.requestAnimationFrame), e.batchedUpdates && (b.batchedUpdates = e.batchedUpdates), e.willAdvance && (Rt = e.willAdvance), e.frameLoop && (b.frameLoop = e.frameLoop);
+}, ve = /* @__PURE__ */ new Set(), N = [], Ke = [], $e = 0, ze = {
+  get idle() {
+    return !ve.size && !N.length;
+  },
+  /** Advance the given animation on every frame until idle. */
+  start(e) {
+    $e > e.priority ? (ve.add(e), b.onStart(wn)) : (wr(e), b(ot));
+  },
+  /** Advance all animations by the given time. */
+  advance: ot,
+  /** Call this when an animation's priority changes. */
+  sort(e) {
+    if ($e)
+      b.onFrame(() => ze.sort(e));
+    else {
+      const t = N.indexOf(e);
+      ~t && (N.splice(t, 1), Rr(e));
+    }
+  },
+  /**
+   * Clear all animations. For testing purposes.
+   *
+   * ☠️ Never call this from within the frameloop.
+   */
+  clear() {
+    N = [], ve.clear();
+  }
+};
+function wn() {
+  ve.forEach(wr), ve.clear(), b(ot);
+}
+function wr(e) {
+  N.includes(e) || Rr(e);
+}
+function Rr(e) {
+  N.splice(
+    Rn(N, (t) => t.priority > e.priority),
+    0,
+    e
+  );
+}
+function ot(e) {
+  const t = Ke;
+  for (let r = 0; r < N.length; r++) {
+    const n = N[r];
+    $e = n.priority, n.idle || (Rt(n), n.advance(e), n.idle || t.push(n));
+  }
+  return $e = 0, Ke = N, Ke.length = 0, N = t, N.length > 0;
+}
+function Rn(e, t) {
+  const r = e.findIndex(t);
+  return r < 0 ? e.length : r;
+}
+var Sn = {
+  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
+}, U = "[-+]?\\d*\\.?\\d+", De = U + "%";
+function Le(...e) {
+  return "\\(\\s*(" + e.join(")\\s*,\\s*(") + ")\\s*\\)";
+}
+var xn = new RegExp("rgb" + Le(U, U, U)), An = new RegExp("rgba" + Le(U, U, U, U)), Pn = new RegExp("hsl" + Le(U, De, De)), En = new RegExp(
+  "hsla" + Le(U, De, De, U)
+), Tn = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, kn = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, Cn = /^#([0-9a-fA-F]{6})$/, In = /^#([0-9a-fA-F]{8})$/;
+function On(e) {
+  let t;
+  return typeof e == "number" ? e >>> 0 === e && e >= 0 && e <= 4294967295 ? e : null : (t = Cn.exec(e)) ? parseInt(t[1] + "ff", 16) >>> 0 : Z && Z[e] !== void 0 ? Z[e] : (t = xn.exec(e)) ? (se(t[1]) << 24 | // r
+  se(t[2]) << 16 | // g
+  se(t[3]) << 8 | // b
+  255) >>> // a
+  0 : (t = An.exec(e)) ? (se(t[1]) << 24 | // r
+  se(t[2]) << 16 | // g
+  se(t[3]) << 8 | // b
+  Ut(t[4])) >>> // a
+  0 : (t = Tn.exec(e)) ? parseInt(
+    t[1] + t[1] + // r
+    t[2] + t[2] + // g
+    t[3] + t[3] + // b
+    "ff",
+    // a
+    16
+  ) >>> 0 : (t = In.exec(e)) ? parseInt(t[1], 16) >>> 0 : (t = kn.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 = Pn.exec(e)) ? ($t(
+    Dt(t[1]),
+    // h
+    je(t[2]),
+    // s
+    je(t[3])
+    // l
+  ) | 255) >>> // a
+  0 : (t = En.exec(e)) ? ($t(
+    Dt(t[1]),
+    // h
+    je(t[2]),
+    // s
+    je(t[3])
+    // l
+  ) | Ut(t[4])) >>> // a
+  0 : null;
+}
+function et(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 $t(e, t, r) {
+  const n = r < 0.5 ? r * (1 + t) : r + t - r * t, s = 2 * r - n, i = et(s, n, e + 1 / 3), a = et(s, n, e), u = et(s, n, e - 1 / 3);
+  return Math.round(i * 255) << 24 | Math.round(a * 255) << 16 | Math.round(u * 255) << 8;
+}
+function se(e) {
+  const t = parseInt(e, 10);
+  return t < 0 ? 0 : t > 255 ? 255 : t;
+}
+function Dt(e) {
+  return (parseFloat(e) % 360 + 360) % 360 / 360;
+}
+function Ut(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 qt(e) {
+  let t = On(e);
+  if (t === null) return e;
+  t = t || 0;
+  const r = (t & 4278190080) >>> 24, n = (t & 16711680) >>> 16, s = (t & 65280) >>> 8, i = (t & 255) / 255;
+  return `rgba(${r}, ${n}, ${s}, ${i})`;
+}
+var be = (e, t, r) => {
+  if (c.fun(e))
+    return e;
+  if (c.arr(e))
+    return be({
+      range: e,
+      output: t,
+      extrapolate: r
+    });
+  if (c.str(e.output[0]))
+    return wt(e);
+  const n = e, s = n.output, i = n.range || [0, 1], a = n.extrapolateLeft || n.extrapolate || "extend", u = n.extrapolateRight || n.extrapolate || "extend", d = n.easing || ((l) => l);
+  return (l) => {
+    const m = Fn(l, i);
+    return jn(
+      l,
+      i[m],
+      i[m + 1],
+      s[m],
+      s[m + 1],
+      d,
+      a,
+      u,
+      n.map
+    );
+  };
+};
+function jn(e, t, r, n, s, i, a, u, d) {
+  let l = d ? d(e) : e;
+  if (l < t) {
+    if (a === "identity") return l;
+    a === "clamp" && (l = t);
+  }
+  if (l > r) {
+    if (u === "identity") return l;
+    u === "clamp" && (l = r);
+  }
+  return n === s ? n : t === r ? e <= t ? n : s : (t === -1 / 0 ? l = -l : r === 1 / 0 ? l = l - t : l = (l - t) / (r - t), l = i(l), n === -1 / 0 ? l = -l : s === 1 / 0 ? l = l + n : l = l * (s - n) + n, l);
+}
+function Fn(e, t) {
+  for (var r = 1; r < t.length - 1 && !(t[r] >= e); ++r)
+    ;
+  return r - 1;
+}
+var Vn = {
+  linear: (e) => e
+}, we = Symbol.for("FluidValue.get"), oe = Symbol.for("FluidValue.observers"), V = (e) => !!(e && e[we]), O = (e) => e && e[we] ? e[we]() : e, Mt = (e) => e[oe] || null;
+function Nn(e, t) {
+  e.eventObserved ? e.eventObserved(t) : e(t);
+}
+function Re(e, t) {
+  const r = e[oe];
+  r && r.forEach((n) => {
+    Nn(n, t);
+  });
+}
+var Sr = class {
+  constructor(e) {
+    if (!e && !(e = this.get))
+      throw Error("Unknown getter");
+    $n(this, e);
+  }
+}, $n = (e, t) => xr(e, we, t);
+function ue(e, t) {
+  if (e[we]) {
+    let r = e[oe];
+    r || xr(e, oe, r = /* @__PURE__ */ new Set()), r.has(t) || (r.add(t), e.observerAdded && e.observerAdded(r.size, t));
+  }
+  return t;
+}
+function Se(e, t) {
+  const r = e[oe];
+  if (r && r.has(t)) {
+    const n = r.size - 1;
+    n ? r.delete(t) : e[oe] = null, e.observerRemoved && e.observerRemoved(n, t);
+  }
+}
+var xr = (e, t, r) => Object.defineProperty(e, t, {
+  value: r,
+  writable: !0,
+  configurable: !0
+}), Ve = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, Dn = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi, zt = new RegExp(`(${Ve.source})(%|[a-z]+)`, "i"), Un = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, Qe = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/, Ar = (e) => {
+  const [t, r] = qn(e);
+  if (!t || bt())
+    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 && Qe.test(r))
+      return Ar(r);
+    if (r)
+      return r;
+  }
+  return e;
+}, qn = (e) => {
+  const t = Qe.exec(e);
+  if (!t) return [,];
+  const [, r, n] = t;
+  return [r, n];
+}, tt, Mn = (e, t, r, n, s) => `rgba(${Math.round(t)}, ${Math.round(r)}, ${Math.round(n)}, ${s})`, Pr = (e) => {
+  tt || (tt = Z ? (
+    // match color names, ignore partial matches
+    new RegExp(`(${Object.keys(Z).join("|")})(?!\\w)`, "g")
+  ) : (
+    // never match
+    /^\b$/
+  ));
+  const t = e.output.map((i) => O(i).replace(Qe, Ar).replace(Dn, qt).replace(tt, qt)), r = t.map((i) => i.match(Ve).map(Number)), s = r[0].map(
+    (i, a) => r.map((u) => {
+      if (!(a in u))
+        throw Error('The arity of each "output" value must be equal');
+      return u[a];
+    })
+  ).map(
+    (i) => be({ ...e, output: i })
+  );
+  return (i) => {
+    var d;
+    const a = !zt.test(t[0]) && ((d = t.find((l) => zt.test(l))) == null ? void 0 : d.replace(Ve, ""));
+    let u = 0;
+    return t[0].replace(
+      Ve,
+      () => `${s[u++](i)}${a || ""}`
+    ).replace(Un, Mn);
+  };
+}, St = "react-spring: ", Er = (e) => {
+  const t = e;
+  let r = !1;
+  if (typeof t != "function")
+    throw new TypeError(`${St}once requires a function parameter`);
+  return (...n) => {
+    r || (t(...n), r = !0);
+  };
+}, zn = Er(console.warn);
+function Ln() {
+  zn(
+    `${St}The "interpolate" function is deprecated in v9 (use "to" instead)`
+  );
+}
+var Qn = Er(console.warn);
+function Gn() {
+  Qn(
+    `${St}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 Ge(e) {
+  return c.str(e) && (e[0] == "#" || /\d/.test(e) || // Do not identify a CSS variable as an AnimatedString if its SSR
+  !bt() && Qe.test(e) || e in (Z || {}));
+}
+var xt = bt() ? Te : Kr, Yn = () => {
+  const e = W(!1);
+  return xt(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), e;
+};
+function Tr() {
+  const e = Fe()[1], t = Yn();
+  return () => {
+    t.current && e(Math.random());
+  };
+}
+var kr = (e) => Te(e, Wn), Wn = [];
+function Lt(e) {
+  const t = W(void 0);
+  return Te(() => {
+    t.current = e;
+  }), t.current;
+}
+var xe = Symbol.for("Animated:node"), Bn = (e) => !!e && e[xe] === e, z = (e) => e && e[xe], At = (e, t) => _n(e, xe, t), Ye = (e) => e && e[xe] && e[xe].getPayload(), Cr = class {
+  constructor() {
+    At(this, this);
+  }
+  /** Get every `AnimatedValue` used by this node. */
+  getPayload() {
+    return this.payload || [];
+  }
+}, We = class Ir extends Cr {
+  constructor(t) {
+    super(), this._value = t, this.done = !0, this.durationProgress = 0, c.num(this._value) && (this.lastPosition = this._value);
+  }
+  /** @internal */
+  static create(t) {
+    return new Ir(t);
+  }
+  getPayload() {
+    return [this];
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(t, r) {
+    return c.num(t) && (this.lastPosition = t, r && (t = Math.round(t / r) * r, this.done && (this.lastPosition = t))), this._value === t ? !1 : (this._value = t, !0);
+  }
+  reset() {
+    const { done: t } = this;
+    this.done = !1, c.num(this._value) && (this.elapsedTime = 0, this.durationProgress = 0, this.lastPosition = this._value, t && (this.lastVelocity = null), this.v0 = null);
+  }
+}, Ue = class Or extends We {
+  constructor(t) {
+    super(0), this._string = null, this._toString = be({
+      output: [t, t]
+    });
+  }
+  /** @internal */
+  static create(t) {
+    return new Or(t);
+  }
+  getValue() {
+    const t = this._string;
+    return t ?? (this._string = this._toString(this._value));
+  }
+  setValue(t) {
+    if (c.str(t)) {
+      if (t == this._string)
+        return !1;
+      this._string = t, this._value = 1;
+    } else if (super.setValue(t))
+      this._string = null;
+    else
+      return !1;
+    return !0;
+  }
+  reset(t) {
+    t && (this._toString = be({
+      output: [this.getValue(), t]
+    })), this._value = 0, super.reset();
+  }
+}, qe = { dependencies: null }, Be = class extends Cr {
+  constructor(e) {
+    super(), this.source = e, this.setValue(e);
+  }
+  getValue(e) {
+    const t = {};
+    return L(this.source, (r, n) => {
+      Bn(r) ? t[n] = r.getValue(e) : V(r) ? t[n] = O(r) : e || (t[n] = r);
+    }), t;
+  }
+  /** Replace the raw object data */
+  setValue(e) {
+    this.source = e, this.payload = this._makePayload(e);
+  }
+  reset() {
+    this.payload && x(this.payload, (e) => e.reset());
+  }
+  /** Create a payload set. */
+  _makePayload(e) {
+    if (e) {
+      const t = /* @__PURE__ */ new Set();
+      return L(e, this._addToPayload, t), Array.from(t);
+    }
+  }
+  /** Add to a payload set. */
+  _addToPayload(e) {
+    qe.dependencies && V(e) && qe.dependencies.add(e);
+    const t = Ye(e);
+    t && x(t, (r) => this.add(r));
+  }
+}, Hn = class jr extends Be {
+  constructor(t) {
+    super(t);
+  }
+  /** @internal */
+  static create(t) {
+    return new jr(t);
+  }
+  getValue() {
+    return this.source.map((t) => t.getValue());
+  }
+  setValue(t) {
+    const r = this.getPayload();
+    return t.length == r.length ? r.map((n, s) => n.setValue(t[s])).some(Boolean) : (super.setValue(t.map(Jn)), !0);
+  }
+};
+function Jn(e) {
+  return (Ge(e) ? Ue : We).create(e);
+}
+function ut(e) {
+  const t = z(e);
+  return t ? t.constructor : c.arr(e) ? Hn : Ge(e) ? Ue : We;
+}
+var Qt = (e, t) => {
+  const r = (
+    // Function components must use "forwardRef" to avoid being
+    // re-rendered on every animation frame.
+    !c.fun(e) || e.prototype && e.prototype.isReactComponent
+  );
+  return en((n, s) => {
+    const i = W(null), a = r && // eslint-disable-next-line react-hooks/rules-of-hooks
+    tn(
+      (_) => {
+        i.current = Kn(s, _);
+      },
+      [s]
+    ), [u, d] = Zn(n, t), l = Tr(), m = () => {
+      const _ = i.current;
+      if (r && !_)
+        return;
+      (_ ? t.applyAnimatedValues(_, u.getValue(!0)) : !1) === !1 && l();
+    }, f = new Xn(m, d), h = W(void 0);
+    xt(() => (h.current = f, x(d, (_) => ue(_, f)), () => {
+      h.current && (x(
+        h.current.deps,
+        (_) => Se(_, h.current)
+      ), b.cancel(h.current.update));
+    })), Te(m, []), kr(() => () => {
+      const _ = h.current;
+      x(_.deps, (v) => Se(v, _));
+    });
+    const p = t.getComponentProps(u.getValue());
+    return /* @__PURE__ */ cr.createElement(e, { ...p, ref: a });
+  });
+}, Xn = class {
+  constructor(e, t) {
+    this.update = e, this.deps = t;
+  }
+  eventObserved(e) {
+    e.type == "change" && b.write(this.update);
+  }
+};
+function Zn(e, t) {
+  const r = /* @__PURE__ */ new Set();
+  return qe.dependencies = r, e.style && (e = {
+    ...e,
+    style: t.createAnimatedStyle(e.style)
+  }), e = new Be(e), qe.dependencies = null, [e, r];
+}
+function Kn(e, t) {
+  return e && (c.fun(e) ? e(t) : e.current = t), t;
+}
+var Gt = Symbol.for("AnimatedComponent"), es = (e, {
+  applyAnimatedValues: t = () => !1,
+  createAnimatedStyle: r = (s) => new Be(s),
+  getComponentProps: n = (s) => s
+} = {}) => {
+  const s = {
+    applyAnimatedValues: t,
+    createAnimatedStyle: r,
+    getComponentProps: n
+  }, i = (a) => {
+    const u = Yt(a) || "Anonymous";
+    return c.str(a) ? a = i[a] || (i[a] = Qt(a, s)) : a = a[Gt] || (a[Gt] = Qt(a, s)), a.displayName = `Animated(${u})`, a;
+  };
+  return L(e, (a, u) => {
+    c.arr(e) && (u = Yt(a)), i[u] = i(a);
+  }), {
+    animated: i
+  };
+}, Yt = (e) => c.str(e) ? e : e && c.str(e.displayName) ? e.displayName : c.fun(e) && e.name || null;
+function ee(e, ...t) {
+  return c.fun(e) ? e(...t) : e;
+}
+var ye = (e, t) => e === !0 || !!(t && e && (c.fun(e) ? e(t) : F(e).includes(t))), Fr = (e, t) => c.obj(e) ? t && e[t] : e, Vr = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, ts = (e) => e, Pt = (e, t = ts) => {
+  let r = rs;
+  e.default && e.default !== !0 && (e = e.default, r = Object.keys(e));
+  const n = {};
+  for (const s of r) {
+    const i = t(e[s], s);
+    c.und(i) || (n[s] = i);
+  }
+  return n;
+}, rs = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+], ns = {
+  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 ss(e) {
+  const t = {};
+  let r = 0;
+  if (L(e, (n, s) => {
+    ns[s] || (t[s] = n, r++);
+  }), r)
+    return t;
+}
+function Nr(e) {
+  const t = ss(e);
+  if (t) {
+    const r = { to: t };
+    return L(e, (n, s) => s in t || (r[s] = n)), r;
+  }
+  return { ...e };
+}
+function Ae(e) {
+  return e = O(e), c.arr(e) ? e.map(Ae) : Ge(e) ? q.createStringInterpolator({
+    range: [0, 1],
+    output: [e, e]
+  })(1) : e;
+}
+function is(e) {
+  for (const t in e) return !0;
+  return !1;
+}
+function lt(e) {
+  return c.fun(e) || c.arr(e) && c.obj(e[0]);
+}
+function as(e, t) {
+  var r;
+  (r = e.ref) == null || r.delete(e), t == null || t.delete(e);
+}
+function os(e, t) {
+  var r;
+  t && e.ref !== t && ((r = e.ref) == null || r.delete(e), t.add(e), e.ref = t);
+}
+var us = {
+  default: { tension: 170, friction: 26 }
+}, ct = {
+  ...us.default,
+  mass: 1,
+  damping: 1,
+  easing: Vn.linear,
+  clamp: !1
+}, ls = class {
+  constructor() {
+    this.velocity = 0, Object.assign(this, ct);
+  }
+};
+function cs(e, t, r) {
+  r && (r = { ...r }, Wt(r, t), t = { ...r, ...t }), Wt(e, t), Object.assign(e, t);
+  for (const a in ct)
+    e[a] == null && (e[a] = ct[a]);
+  let { frequency: n, damping: s } = e;
+  const { mass: i } = e;
+  return c.und(n) || (n < 0.01 && (n = 0.01), s < 0 && (s = 0), e.tension = Math.pow(2 * Math.PI / n, 2) * i, e.friction = 4 * Math.PI * s * i / n), e;
+}
+function Wt(e, t) {
+  if (!c.und(t.decay))
+    e.duration = void 0;
+  else {
+    const r = !c.und(t.tension) || !c.und(t.friction);
+    (r || !c.und(t.frequency) || !c.und(t.damping) || !c.und(t.mass)) && (e.duration = void 0, e.decay = void 0), r && (e.frequency = void 0);
+  }
+}
+var Bt = [], ds = class {
+  constructor() {
+    this.changed = !1, this.values = Bt, this.toValues = null, this.fromValues = Bt, this.config = new ls(), this.immediate = !1;
+  }
+};
+function $r(e, { key: t, props: r, defaultProps: n, state: s, actions: i }) {
+  return new Promise((a, u) => {
+    let d, l, m = ye(r.cancel ?? (n == null ? void 0 : n.cancel), t);
+    if (m)
+      p();
+    else {
+      c.und(r.pause) || (s.paused = ye(r.pause, t));
+      let _ = n == null ? void 0 : n.pause;
+      _ !== !0 && (_ = s.paused || ye(_, t)), d = ee(r.delay || 0, t), _ ? (s.resumeQueue.add(h), i.pause()) : (i.resume(), h());
+    }
+    function f() {
+      s.resumeQueue.add(h), s.timeouts.delete(l), l.cancel(), d = l.time - b.now();
+    }
+    function h() {
+      d > 0 && !q.skipAnimation ? (s.delayed = !0, l = b.setTimeout(p, d), s.pauseQueue.add(f), s.timeouts.add(l)) : p();
+    }
+    function p() {
+      s.delayed && (s.delayed = !1), s.pauseQueue.delete(f), s.timeouts.delete(l), e <= (s.cancelId || 0) && (m = !0);
+      try {
+        i.start({ ...r, callId: e, cancel: m }, a);
+      } catch (_) {
+        u(_);
+      }
+    }
+  });
+}
+var Et = (e, t) => t.length == 1 ? t[0] : t.some((r) => r.cancelled) ? ae(e.get()) : t.every((r) => r.noop) ? Dr(e.get()) : $(
+  e.get(),
+  t.every((r) => r.finished)
+), Dr = (e) => ({
+  value: e,
+  noop: !0,
+  finished: !0,
+  cancelled: !1
+}), $ = (e, t, r = !1) => ({
+  value: e,
+  finished: t,
+  cancelled: r
+}), ae = (e) => ({
+  value: e,
+  cancelled: !0,
+  finished: !1
+});
+function Ur(e, t, r, n) {
+  const { callId: s, parentId: i, onRest: a } = t, { asyncTo: u, promise: d } = r;
+  return !i && e === u && !t.reset ? d : r.promise = (async () => {
+    r.asyncId = s, r.asyncTo = e;
+    const l = Pt(
+      t,
+      (w, g) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        g === "onRest" ? void 0 : w
+      )
+    );
+    let m, f;
+    const h = new Promise(
+      (w, g) => (m = w, f = g)
+    ), p = (w) => {
+      const g = (
+        // The `cancel` prop or `stop` method was used.
+        s <= (r.cancelId || 0) && ae(n) || // The async `to` prop was replaced.
+        s !== r.asyncId && $(n, !1)
+      );
+      if (g)
+        throw w.result = g, f(w), w;
+    }, _ = (w, g) => {
+      const R = new Ht(), y = new Jt();
+      return (async () => {
+        if (q.skipAnimation)
+          throw Pe(r), y.result = $(n, !1), f(y), y;
+        p(R);
+        const A = c.obj(w) ? { ...w } : { ...g, to: w };
+        A.parentId = s, L(l, (Q, I) => {
+          c.und(A[I]) && (A[I] = Q);
+        });
+        const P = await n.start(A);
+        return p(R), r.paused && await new Promise((Q) => {
+          r.resumeQueue.add(Q);
+        }), P;
+      })();
+    };
+    let v;
+    if (q.skipAnimation)
+      return Pe(r), $(n, !1);
+    try {
+      let w;
+      c.arr(e) ? w = (async (g) => {
+        for (const R of g)
+          await _(R);
+      })(e) : w = Promise.resolve(e(_, n.stop.bind(n))), await Promise.all([w.then(m), h]), v = $(n.get(), !0, !1);
+    } catch (w) {
+      if (w instanceof Ht)
+        v = w.result;
+      else if (w instanceof Jt)
+        v = w.result;
+      else
+        throw w;
+    } finally {
+      s == r.asyncId && (r.asyncId = i, r.asyncTo = i ? u : void 0, r.promise = i ? d : void 0);
+    }
+    return c.fun(a) && b.batchedUpdates(() => {
+      a(v, n, n.item);
+    }), v;
+  })();
+}
+function Pe(e, t) {
+  ge(e.timeouts, (r) => r.cancel()), e.pauseQueue.clear(), e.resumeQueue.clear(), e.asyncId = e.asyncTo = e.promise = void 0, t && (e.cancelId = t);
+}
+var Ht = 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."
+    );
+  }
+}, Jt = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+}, dt = (e) => e instanceof Tt, fs = 1, Tt = class extends Sr {
+  constructor() {
+    super(...arguments), this.id = fs++, 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 = z(this);
+    return e && e.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...e) {
+    return q.to(this, e);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...e) {
+    return Ln(), q.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) {
+    Re(this, {
+      type: "change",
+      parent: this,
+      value: e,
+      idle: t
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(e) {
+    this.idle || ze.sort(this), Re(this, {
+      type: "priority",
+      parent: this,
+      priority: e
+    });
+  }
+}, te = Symbol.for("SpringPhase"), qr = 1, ft = 2, ht = 4, rt = (e) => (e[te] & qr) > 0, H = (e) => (e[te] & ft) > 0, de = (e) => (e[te] & ht) > 0, Xt = (e, t) => t ? e[te] |= ft | qr : e[te] &= ~ft, Zt = (e, t) => t ? e[te] |= ht : e[te] &= ~ht, hs = class extends Tt {
+  constructor(e, t) {
+    if (super(), this.animation = new ds(), 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, !c.und(e) || !c.und(t)) {
+      const r = c.obj(e) ? { ...e } : { ...t, from: e };
+      c.und(r.default) && (r.default = !0), this.start(r);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(H(this) || this._state.asyncTo) || de(this);
+  }
+  get goal() {
+    return O(this.animation.to);
+  }
+  get velocity() {
+    const e = z(this);
+    return e instanceof We ? e.lastVelocity || 0 : e.getPayload().map((t) => t.lastVelocity || 0);
+  }
+  /**
+   * When true, this value has been animated at least once.
+   */
+  get hasAnimated() {
+    return rt(this);
+  }
+  /**
+   * When true, this value has an unfinished animation,
+   * which is either active or paused.
+   */
+  get isAnimating() {
+    return H(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return de(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: i } = n, a = Ye(n.to);
+    !a && V(n.to) && (s = F(O(n.to))), n.values.forEach((l, m) => {
+      if (l.done) return;
+      const f = (
+        // Animated strings always go from 0 to 1.
+        l.constructor == Ue ? 1 : a ? a[m].lastPosition : s[m]
+      );
+      let h = n.immediate, p = f;
+      if (!h) {
+        if (p = l.lastPosition, i.tension <= 0) {
+          l.done = !0;
+          return;
+        }
+        let _ = l.elapsedTime += e;
+        const v = n.fromValues[m], w = l.v0 != null ? l.v0 : l.v0 = c.arr(i.velocity) ? i.velocity[m] : i.velocity;
+        let g;
+        const R = i.precision || (v == f ? 5e-3 : Math.min(1, Math.abs(f - v) * 1e-3));
+        if (c.und(i.duration))
+          if (i.decay) {
+            const y = i.decay === !0 ? 0.998 : i.decay, A = Math.exp(-(1 - y) * _);
+            p = v + w / (1 - y) * (1 - A), h = Math.abs(l.lastPosition - p) <= R, g = w * A;
+          } else {
+            g = l.lastVelocity == null ? w : l.lastVelocity;
+            const y = i.restVelocity || R / 10, A = i.clamp ? 0 : i.bounce, P = !c.und(A), Q = v == f ? l.v0 > 0 : v < f;
+            let I, re = !1;
+            const C = 1, K = Math.ceil(e / C);
+            for (let j = 0; j < K && (I = Math.abs(g) > y, !(!I && (h = Math.abs(f - p) <= R, h))); ++j) {
+              P && (re = p == f || p > f == Q, re && (g = -g * A, p = f));
+              const M = -i.tension * 1e-6 * (p - f), G = -i.friction * 1e-3 * g, He = (M + G) / i.mass;
+              g = g + He * C, p = p + g * C;
+            }
+          }
+        else {
+          let y = 1;
+          i.duration > 0 && (this._memoizedDuration !== i.duration && (this._memoizedDuration = i.duration, l.durationProgress > 0 && (l.elapsedTime = i.duration * l.durationProgress, _ = l.elapsedTime += e)), y = (i.progress || 0) + _ / this._memoizedDuration, y = y > 1 ? 1 : y < 0 ? 0 : y, l.durationProgress = y), p = v + i.easing(y) * (f - v), g = (p - l.lastPosition) / e, h = y == 1;
+        }
+        l.lastVelocity = g, Number.isNaN(p) && (console.warn("Got NaN while animating:", this), h = !0);
+      }
+      a && !a[m].done && (h = !1), h ? l.done = !0 : t = !1, l.setValue(p, i.round) && (r = !0);
+    });
+    const u = z(this), d = u.getValue();
+    if (t) {
+      const l = O(n.to);
+      (d !== l || r) && !i.decay ? (u.setValue(l), this._onChange(l)) : r && i.decay && this._onChange(d), this._stop();
+    } else r && this._onChange(d);
+  }
+  /** Set the current value, while stopping the current animation */
+  set(e) {
+    return b.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 (H(this)) {
+      const { to: e, config: t } = this.animation;
+      b.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 c.und(e) ? (r = this.queue || [], this.queue = []) : r = [c.obj(e) ? e : { ...t, to: e }], Promise.all(
+      r.map((n) => this._update(n))
+    ).then((n) => Et(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()), Pe(this._state, e && this._lastCallId), b.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 = c.obj(r) ? r[t] : r, (r == null || lt(r)) && (r = void 0), n = c.obj(n) ? n[t] : n, n == null && (n = void 0);
+    const s = { to: r, from: n };
+    return rt(this) || (e.reverse && ([r, n] = [n, r]), n = O(n), c.und(n) ? z(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,
+      Pt(
+        e,
+        (a, u) => /^on/.test(u) ? Fr(a, r) : a
+      )
+    ), er(this, e, "onProps"), he(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 i = this._state;
+    return $r(++this._lastCallId, {
+      key: r,
+      props: e,
+      defaultProps: n,
+      state: i,
+      actions: {
+        pause: () => {
+          de(this) || (Zt(this, !0), pe(i.pauseQueue), he(
+            this,
+            "onPause",
+            $(this, fe(this, this.animation.to)),
+            this
+          ));
+        },
+        resume: () => {
+          de(this) && (Zt(this, !1), H(this) && this._resume(), pe(i.resumeQueue), he(
+            this,
+            "onResume",
+            $(this, fe(this, this.animation.to)),
+            this
+          ));
+        },
+        start: this._merge.bind(this, s)
+      }
+    }).then((a) => {
+      if (e.loop && a.finished && !(t && a.noop)) {
+        const u = Mr(e);
+        if (u)
+          return this._update(u, !0);
+      }
+      return a;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(e, t, r) {
+    if (t.cancel)
+      return this.stop(!0), r(ae(this));
+    const n = !c.und(e.to), s = !c.und(e.from);
+    if (n || s)
+      if (t.callId > this._lastToId)
+        this._lastToId = t.callId;
+      else
+        return r(ae(this));
+    const { key: i, defaultProps: a, animation: u } = this, { to: d, from: l } = u;
+    let { to: m = d, from: f = l } = e;
+    s && !n && (!t.default || c.und(m)) && (m = f), t.reverse && ([m, f] = [f, m]);
+    const h = !Y(f, l);
+    h && (u.from = f), f = O(f);
+    const p = !Y(m, d);
+    p && this._focus(m);
+    const _ = lt(t.to), { config: v } = u, { decay: w, velocity: g } = v;
+    (n || s) && (v.velocity = 0), t.config && !_ && cs(
+      v,
+      ee(t.config, i),
+      // Avoid calling the same "config" prop twice.
+      t.config !== a.config ? ee(a.config, i) : void 0
+    );
+    let R = z(this);
+    if (!R || c.und(m))
+      return r($(this, !0));
+    const y = (
+      // 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.
+      c.und(t.reset) ? s && !t.default : !c.und(f) && ye(t.reset, i)
+    ), A = y ? f : this.get(), P = Ae(m), Q = c.num(P) || c.arr(P) || Ge(P), I = !_ && (!Q || ye(a.immediate || t.immediate, i));
+    if (p) {
+      const j = ut(m);
+      if (j !== R.constructor)
+        if (I)
+          R = this._set(P);
+        else
+          throw Error(
+            `Cannot animate between ${R.constructor.name} and ${j.name}, as the "to" prop suggests`
+          );
+    }
+    const re = R.constructor;
+    let C = V(m), K = !1;
+    if (!C) {
+      const j = y || !rt(this) && h;
+      (p || j) && (K = Y(Ae(A), P), C = !K), (!Y(u.immediate, I) && !I || !Y(v.decay, w) || !Y(v.velocity, g)) && (C = !0);
+    }
+    if (K && H(this) && (u.changed && !y ? C = !0 : C || this._stop(d)), !_ && ((C || V(d)) && (u.values = R.getPayload(), u.toValues = V(m) ? null : re == Ue ? [1] : F(P)), u.immediate != I && (u.immediate = I, !I && !y && this._set(d)), C)) {
+      const { onRest: j } = u;
+      x(ps, (G) => er(this, t, G));
+      const M = $(this, fe(this, d));
+      pe(this._pendingCalls, M), this._pendingCalls.add(r), u.changed && b.batchedUpdates(() => {
+        var G;
+        u.changed = !y, j == null || j(M, this), y ? ee(a.onRest, M) : (G = u.onStart) == null || G.call(u, M, this);
+      });
+    }
+    y && this._set(A), _ ? r(Ur(t.to, t, this._state, this)) : C ? this._start() : H(this) && !p ? this._pendingCalls.add(r) : r(Dr(A));
+  }
+  /** Update the `animation.to` value, which might be a `FluidValue` */
+  _focus(e) {
+    const t = this.animation;
+    e !== t.to && (Mt(this) && this._detach(), t.to = e, Mt(this) && this._attach());
+  }
+  _attach() {
+    let e = 0;
+    const { to: t } = this.animation;
+    V(t) && (ue(t, this), dt(t) && (e = t.priority + 1)), this.priority = e;
+  }
+  _detach() {
+    const { to: e } = this.animation;
+    V(e) && Se(e, this);
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(e, t = !0) {
+    const r = O(e);
+    if (!c.und(r)) {
+      const n = z(this);
+      if (!n || !Y(r, n.getValue())) {
+        const s = ut(r);
+        !n || n.constructor != s ? At(this, s.create(r)) : n.setValue(r), n && b.batchedUpdates(() => {
+          this._onChange(r, t);
+        });
+      }
+    }
+    return z(this);
+  }
+  _onStart() {
+    const e = this.animation;
+    e.changed || (e.changed = !0, he(
+      this,
+      "onStart",
+      $(this, fe(this, e.to)),
+      this
+    ));
+  }
+  _onChange(e, t) {
+    t || (this._onStart(), ee(this.animation.onChange, e, this)), ee(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;
+    z(this).reset(O(e.to)), e.immediate || (e.fromValues = e.values.map((t) => t.lastPosition)), H(this) || (Xt(this, !0), de(this) || this._resume());
+  }
+  _resume() {
+    q.skipAnimation ? this.finish() : ze.start(this);
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(e, t) {
+    if (H(this)) {
+      Xt(this, !1);
+      const r = this.animation;
+      x(r.values, (s) => {
+        s.done = !0;
+      }), r.toValues && (r.onChange = r.onPause = r.onResume = void 0), Re(this, {
+        type: "idle",
+        parent: this
+      });
+      const n = t ? ae(this.get()) : $(this.get(), fe(this, e ?? r.to));
+      pe(this._pendingCalls, n), r.changed && (r.changed = !1, he(this, "onRest", n, this));
+    }
+  }
+};
+function fe(e, t) {
+  const r = Ae(t), n = Ae(e.get());
+  return Y(n, r);
+}
+function Mr(e, t = e.loop, r = e.to) {
+  const n = ee(t);
+  if (n) {
+    const s = n !== !0 && Nr(n), i = (s || e).reverse, a = !s || s.reset;
+    return Ee({
+      ...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: !i || lt(r) ? r : void 0,
+      // Ignore the "from" prop except on reset.
+      from: a ? e.from : void 0,
+      reset: a,
+      // The "loop" prop can return a "useSpring" props object to
+      // override any of the original props.
+      ...s
+    });
+  }
+}
+function Ee(e) {
+  const { to: t, from: r } = e = Nr(e), n = /* @__PURE__ */ new Set();
+  return c.obj(t) && Kt(t, n), c.obj(r) && Kt(r, n), e.keys = n.size ? Array.from(n) : null, e;
+}
+function ms(e) {
+  const t = Ee(e);
+  return c.und(t.default) && (t.default = Pt(t)), t;
+}
+function Kt(e, t) {
+  L(e, (r, n) => r != null && t.add(n));
+}
+var ps = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function er(e, t, r) {
+  e.animation[r] = t[r] !== Vr(t, r) ? Fr(t[r], e.key) : void 0;
+}
+function he(e, t, ...r) {
+  var n, s, i, a;
+  (s = (n = e.animation)[t]) == null || s.call(n, ...r), (a = (i = e.defaultProps)[t]) == null || a.call(i, ...r);
+}
+var gs = ["onStart", "onChange", "onRest"], vs = 1, ys = class {
+  constructor(e, t) {
+    this.id = vs++, 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];
+      c.und(r) || this.springs[t].set(r);
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(e) {
+    return e && this.queue.push(Ee(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 = F(e).map(Ee) : this.queue = [], this._flush ? this._flush(this, t) : (Yr(this, t), mt(this, t));
+  }
+  /** @internal */
+  stop(e, t) {
+    if (e !== !!e && (t = e), t) {
+      const r = this.springs;
+      x(F(t), (n) => r[n].stop(!!e));
+    } else
+      Pe(this._state, this._lastAsyncId), this.each((r) => r.stop(!!e));
+    return this;
+  }
+  /** Freeze the active animation in time */
+  pause(e) {
+    if (c.und(e))
+      this.start({ pause: !0 });
+    else {
+      const t = this.springs;
+      x(F(e), (r) => t[r].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(e) {
+    if (c.und(e))
+      this.start({ pause: !1 });
+    else {
+      const t = this.springs;
+      x(F(e), (r) => t[r].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(e) {
+    L(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, ge(e, ([u, d]) => {
+      d.value = this.get(), u(d, this, this._item);
+    }));
+    const i = !n && this._started, a = s || i && r.size ? this.get() : null;
+    s && t.size && ge(t, ([u, d]) => {
+      d.value = a, u(d, this, this._item);
+    }), i && (this._started = !1, ge(r, ([u, d]) => {
+      d.value = a, u(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;
+    b.onFrame(this._onFrame);
+  }
+};
+function mt(e, t) {
+  return Promise.all(t.map((r) => zr(e, r))).then(
+    (r) => Et(e, r)
+  );
+}
+async function zr(e, t, r) {
+  const { keys: n, to: s, from: i, loop: a, onRest: u, onResolve: d } = t, l = c.obj(t.default) && t.default;
+  a && (t.loop = !1), s === !1 && (t.to = null), i === !1 && (t.from = null);
+  const m = c.arr(s) || c.fun(s) ? s : void 0;
+  m ? (t.to = void 0, t.onRest = void 0, l && (l.onRest = void 0)) : x(gs, (v) => {
+    const w = t[v];
+    if (c.fun(w)) {
+      const g = e._events[v];
+      t[v] = ({ finished: R, cancelled: y }) => {
+        const A = g.get(w);
+        A ? (R || (A.finished = !1), y && (A.cancelled = !0)) : g.set(w, {
+          value: null,
+          finished: R || !1,
+          cancelled: y || !1
+        });
+      }, l && (l[v] = t[v]);
+    }
+  });
+  const f = e._state;
+  t.pause === !f.paused ? (f.paused = t.pause, pe(t.pause ? f.pauseQueue : f.resumeQueue)) : f.paused && (t.pause = !0);
+  const h = (n || Object.keys(e.springs)).map(
+    (v) => e.springs[v].start(t)
+  ), p = t.cancel === !0 || Vr(t, "cancel") === !0;
+  (m || p && f.asyncId) && h.push(
+    $r(++e._lastAsyncId, {
+      props: t,
+      state: f,
+      actions: {
+        pause: at,
+        resume: at,
+        start(v, w) {
+          p ? (Pe(f, e._lastAsyncId), w(ae(e))) : (v.onRest = u, w(
+            Ur(
+              m,
+              v,
+              f,
+              e
+            )
+          ));
+        }
+      }
+    })
+  ), f.paused && await new Promise((v) => {
+    f.resumeQueue.add(v);
+  });
+  const _ = Et(e, await Promise.all(h));
+  if (a && _.finished && !(r && _.noop)) {
+    const v = Mr(t, a, s);
+    if (v)
+      return Yr(e, [v]), zr(e, v, !0);
+  }
+  return d && b.batchedUpdates(() => d(_, e, e.item)), _;
+}
+function tr(e, t) {
+  const r = { ...e.springs };
+  return t && x(F(t), (n) => {
+    c.und(n.keys) && (n = Ee(n)), c.obj(n.to) || (n = { ...n, to: void 0 }), Gr(r, n, (s) => Qr(s));
+  }), Lr(e, r), r;
+}
+function Lr(e, t) {
+  L(t, (r, n) => {
+    e.springs[n] || (e.springs[n] = r, ue(r, e));
+  });
+}
+function Qr(e, t) {
+  const r = new hs();
+  return r.key = e, t && ue(r, t), r;
+}
+function Gr(e, t, r) {
+  t.keys && x(t.keys, (n) => {
+    (e[n] || (e[n] = r(n)))._prepareNode(t);
+  });
+}
+function Yr(e, t) {
+  x(t, (r) => {
+    Gr(e.springs, r, (n) => Qr(n, e));
+  });
+}
+var _s = cr.createContext({
+  pause: !1,
+  immediate: !1
+}), bs = () => {
+  const e = [], t = function(n) {
+    Gn();
+    const s = [];
+    return x(e, (i, a) => {
+      if (c.und(n))
+        s.push(i.start());
+      else {
+        const u = r(n, i, a);
+        u && s.push(i.start(u));
+      }
+    }), 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 x(e, (n) => n.pause(...arguments)), this;
+  }, t.resume = function() {
+    return x(e, (n) => n.resume(...arguments)), this;
+  }, t.set = function(n) {
+    x(e, (s, i) => {
+      const a = c.fun(n) ? n(i, s) : n;
+      a && s.set(a);
+    });
+  }, t.start = function(n) {
+    const s = [];
+    return x(e, (i, a) => {
+      if (c.und(n))
+        s.push(i.start());
+      else {
+        const u = this._getProps(n, i, a);
+        u && s.push(i.start(u));
+      }
+    }), s;
+  }, t.stop = function() {
+    return x(e, (n) => n.stop(...arguments)), this;
+  }, t.update = function(n) {
+    return x(e, (s, i) => s.update(this._getProps(n, s, i))), this;
+  };
+  const r = function(n, s, i) {
+    return c.fun(n) ? n(i, s) : n;
+  };
+  return t._getProps = r, t;
+};
+function ws(e, t, r) {
+  const n = c.fun(t) && t;
+  n && !r && (r = []);
+  const s = me(
+    () => n || arguments.length == 3 ? bs() : void 0,
+    []
+  ), i = W(0), a = Tr(), u = me(
+    () => ({
+      ctrls: [],
+      queue: [],
+      flush(g, R) {
+        const y = tr(g, R);
+        return i.current > 0 && !u.queue.length && !Object.keys(y).some((P) => !g.springs[P]) ? mt(g, R) : new Promise((P) => {
+          Lr(g, y), u.queue.push(() => {
+            P(mt(g, R));
+          }), a();
+        });
+      }
+    }),
+    []
+  ), d = W([...u.ctrls]), l = W([]), m = Lt(e) || 0;
+  me(() => {
+    x(d.current.slice(e, m), (g) => {
+      as(g, s), g.stop(!0);
+    }), d.current.length = e, f(m, e);
+  }, [e]), me(() => {
+    f(0, Math.min(m, e));
+  }, r);
+  function f(g, R) {
+    for (let y = g; y < R; y++) {
+      const A = d.current[y] || (d.current[y] = new ys(null, u.flush)), P = n ? n(y, A) : t[y];
+      P && (l.current[y] = ms(P));
+    }
+  }
+  const h = d.current.map(
+    (g, R) => tr(g, l.current[R])
+  ), p = dr(_s), _ = Lt(p), v = p !== _ && is(p);
+  xt(() => {
+    i.current++, u.ctrls = d.current;
+    const { queue: g } = u;
+    g.length && (u.queue = [], x(g, (R) => R())), x(d.current, (R, y) => {
+      s == null || s.add(R), v && R.start({ default: p });
+      const A = l.current[y];
+      A && (os(R, A.ref), R.ref ? R.queue.push(A) : R.start(A));
+    });
+  }), kr(() => () => {
+    x(u.ctrls, (g) => g.stop(!0));
+  });
+  const w = h.map((g) => ({ ...g }));
+  return s ? [w, s] : w;
+}
+function rr(e, t) {
+  const r = c.fun(e), [[n], s] = ws(
+    1,
+    r ? e : [e],
+    r ? [] : t
+  );
+  return r || arguments.length == 2 ? [n, s] : n;
+}
+var Rs = class extends Tt {
+  constructor(e, t) {
+    super(), this.source = e, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = be(...t);
+    const r = this._get(), n = ut(r);
+    At(this, n.create(r));
+  }
+  advance(e) {
+    const t = this._get(), r = this.get();
+    Y(t, r) || (z(this).setValue(t), this._onChange(t, this.idle)), !this.idle && nr(this._active) && nt(this);
+  }
+  _get() {
+    const e = c.arr(this.source) ? this.source.map(O) : F(O(this.source));
+    return this.calc(...e);
+  }
+  _start() {
+    this.idle && !nr(this._active) && (this.idle = !1, x(Ye(this), (e) => {
+      e.done = !1;
+    }), q.skipAnimation ? (b.batchedUpdates(() => this.advance()), nt(this)) : ze.start(this));
+  }
+  // Observe our sources only when we're observed.
+  _attach() {
+    let e = 1;
+    x(F(this.source), (t) => {
+      V(t) && ue(t, this), dt(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() {
+    x(F(this.source), (e) => {
+      V(e) && Se(e, this);
+    }), this._active.clear(), nt(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 = F(this.source).reduce(
+      (t, r) => Math.max(t, (dt(r) ? r.priority : 0) + 1),
+      0
+    ));
+  }
+};
+function Ss(e) {
+  return e.idle !== !1;
+}
+function nr(e) {
+  return !e.size || Array.from(e).every(Ss);
+}
+function nt(e) {
+  e.idle || (e.idle = !0, x(Ye(e), (t) => {
+    t.done = !0;
+  }), Re(e, {
+    type: "idle",
+    parent: e
+  }));
+}
+q.assign({
+  createStringInterpolator: Pr,
+  to: (e, t) => new Rs(e, t)
+});
+var Wr = /^--/;
+function xs(e, t) {
+  return t == null || typeof t == "boolean" || t === "" ? "" : typeof t == "number" && t !== 0 && !Wr.test(e) && !(_e.hasOwnProperty(e) && _e[e]) ? t + "px" : ("" + t).trim();
+}
+var sr = {};
+function As(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: i,
+    scrollTop: a,
+    scrollLeft: u,
+    viewBox: d,
+    ...l
+  } = t, m = Object.values(l), f = Object.keys(l).map(
+    (h) => r || e.hasAttribute(h) ? h : sr[h] || (sr[h] = h.replace(
+      /([A-Z])/g,
+      // Attributes are written in dash case
+      (p) => "-" + p.toLowerCase()
+    ))
+  );
+  i !== void 0 && (e.textContent = i);
+  for (const h in s)
+    if (s.hasOwnProperty(h)) {
+      const p = xs(h, s[h]);
+      Wr.test(h) ? e.style.setProperty(h, p) : e.style[h] = p;
+    }
+  f.forEach((h, p) => {
+    e.setAttribute(h, m[p]);
+  }), n !== void 0 && (e.className = n), a !== void 0 && (e.scrollTop = a), u !== void 0 && (e.scrollLeft = u), d !== void 0 && e.setAttribute("viewBox", d);
+}
+var _e = {
+  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
+}, Ps = (e, t) => e + t.charAt(0).toUpperCase() + t.substring(1), Es = ["Webkit", "Ms", "Moz", "O"];
+_e = Object.keys(_e).reduce((e, t) => (Es.forEach((r) => e[Ps(r, t)] = e[t]), e), _e);
+var Ts = /^(matrix|translate|scale|rotate|skew)/, ks = /^(translate)/, Cs = /^(rotate|skew)/, st = (e, t) => c.num(e) && e !== 0 ? e + t : e, Ne = (e, t) => c.arr(e) ? e.every((r) => Ne(r, t)) : c.num(e) ? e === t : parseFloat(e) === t, Is = class extends Be {
+  constructor({ x: e, y: t, z: r, ...n }) {
+    const s = [], i = [];
+    (e || t || r) && (s.push([e || 0, t || 0, r || 0]), i.push((a) => [
+      `translate3d(${a.map((u) => st(u, "px")).join(",")})`,
+      // prettier-ignore
+      Ne(a, 0)
+    ])), L(n, (a, u) => {
+      if (u === "transform")
+        s.push([a || ""]), i.push((d) => [d, d === ""]);
+      else if (Ts.test(u)) {
+        if (delete n[u], c.und(a)) return;
+        const d = ks.test(u) ? "px" : Cs.test(u) ? "deg" : "";
+        s.push(F(a)), i.push(
+          u === "rotate3d" ? ([l, m, f, h]) => [
+            `rotate3d(${l},${m},${f},${st(h, d)})`,
+            Ne(h, 0)
+          ] : (l) => [
+            `${u}(${l.map((m) => st(m, d)).join(",")})`,
+            Ne(l, u.startsWith("scale") ? 1 : 0)
+          ]
+        );
+      }
+    }), s.length && (n.transform = new Os(s, i)), super(n);
+  }
+}, Os = class extends Sr {
+  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 x(this.inputs, (r, n) => {
+      const s = O(r[0]), [i, a] = this.transforms[n](
+        c.arr(s) ? s : r.map(O)
+      );
+      e += " " + i, t = t && a;
+    }), t ? "none" : e;
+  }
+  // Start observing our inputs once we have an observer.
+  observerAdded(e) {
+    e == 1 && x(
+      this.inputs,
+      (t) => x(
+        t,
+        (r) => V(r) && ue(r, this)
+      )
+    );
+  }
+  // Stop observing our inputs once we have no observers.
+  observerRemoved(e) {
+    e == 0 && x(
+      this.inputs,
+      (t) => x(
+        t,
+        (r) => V(r) && Se(r, this)
+      )
+    );
+  }
+  eventObserved(e) {
+    e.type == "change" && (this._value = null), Re(this, e);
+  }
+}, js = [
+  "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"
+];
+q.assign({
+  batchedUpdates: fn,
+  createStringInterpolator: Pr,
+  colors: Sn
+});
+var Fs = es(js, {
+  applyAnimatedValues: As,
+  createAnimatedStyle: (e) => new Is(e),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getComponentProps: ({ scrollTop: e, scrollLeft: t, ...r }) => r
+}), ir = Fs.animated;
+const Br = rn({}), Vs = ({ children: e }) => {
+  const { app: t } = nn(), r = me(() => {
+    if (!t || !t.renderer) return null;
+    const n = new fr();
+    n.setFillStyle({
+      color: "#1e1524"
+    }), n.rect(0, 0, 1, 1), n.fill();
+    const s = t.renderer.generateTexture(n);
+    return n.destroy(), s;
+  }, [t == null ? void 0 : t.renderer]);
+  return r ? /* @__PURE__ */ D.jsx(Br.Provider, { value: r, children: e }) : null;
+};
+class Ns extends hr {
+  constructor(r, n, s, i, a, u) {
+    super({ texture: r, x: n, y: s, scaleX: i, scaleY: a, alpha: 0 });
+    B(this, "animationProgress", 0);
+    B(this, "delayCounter", 0);
+    B(this, "randomSpeed");
+    B(this, "randomDelayOffset");
+    B(this, "startScaleX");
+    B(this, "startScaleY");
+    this.texture = r, this.x = n, this.y = s, this.scaleX = i, this.scaleY = a, this.curLevel = u, this.startScaleX = i, this.startScaleY = a, this.curLevel = u, this.randomSpeed = 0.04 + Math.random() * 0.04, this.randomDelayOffset = Math.floor(Math.random() * 150);
+  }
+  update() {
+    if (this.delayCounter < this.curLevel * 15 + this.randomDelayOffset) {
+      this.delayCounter++;
+      return;
+    }
+    const r = 1;
+    this.animationProgress += (r - this.animationProgress) * this.randomSpeed, this.alpha = this.animationProgress;
+  }
+}
+class $s {
+  constructor(t, r) {
+    B(this, "cells", []);
+    this.texture = t, this.particleContainerRefCurrent = r, this.texture = t;
+  }
+  add(t, r, n, s, i) {
+    const a = new Ns(this.texture, t, r, n, s, i);
+    this.particleContainerRefCurrent.addParticle(a), this.cells.push(a);
+  }
+  updateAll() {
+    for (const t of this.cells)
+      t.update();
+  }
+}
+const Ds = ({
+  gridRows: e,
+  gridCols: t,
+  cellWidth: r,
+  cellHeight: n,
+  gridDepth: s
+}) => {
+  const i = dr(Br), a = W(null), u = W(null);
+  Te(() => {
+    a.current && (u.current = new $s(
+      i,
+      a.current
+    ), d(
+      0,
+      0,
+      r,
+      n,
+      t,
+      e,
+      s,
+      a.current
+    ));
+  }, []), sn(() => {
+    var l;
+    (l = u.current) == null || l.updateAll();
+  });
+  const d = (l, m, f, h, p, _, v, w) => {
+    var g;
+    for (let R = 0; R < _; R++)
+      for (let y = 0; y < p; y++) {
+        const A = l + y * f, P = m + R * h;
+        v <= 0 || Math.random() > 0.7 && v < s ? Math.random() > 0.1 && ((g = u.current) == null || g.add(
+          A,
+          P,
+          f - 1,
+          h - 1,
+          v
+        )) : d(
+          A,
+          P,
+          f / p,
+          h / _,
+          p,
+          _,
+          v - 1
+        );
+      }
+  };
+  return /* @__PURE__ */ D.jsx(
+    "pixiParticleContainer",
+    {
+      ref: a,
+      dynamicProperties: {
+        position: !0,
+        vertex: !0,
+        color: !0
+      }
+    }
+  );
+}, Us = ({
+  cellWidth: e,
+  cellHeight: t,
+  gridRows: r,
+  gridCols: n,
+  gridDepth: s
+}) => /* @__PURE__ */ D.jsx(Vs, { children: /* @__PURE__ */ D.jsx(
+  Ds,
+  {
+    cellWidth: e,
+    cellHeight: t,
+    gridCols: n,
+    gridRows: r,
+    gridDepth: s
+  }
+) }), qs = (e) => /* @__PURE__ */ D.jsx(
+  "svg",
+  {
+    viewBox: "10 0 489.935 489.935",
+    fill: "currentColor",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...e,
+    children: /* @__PURE__ */ D.jsx(
+      "path",
+      {
+        d: `M278.235,33.267c-116.7,0-211.6,95-211.6,211.7v0.7l-41.9-63.1c-4.1-6.2-12.5-7.9-18.7-3.8c-6.2,4.1-7.9,12.5-3.8,18.7 \r
+    l60.8,91.5c2.2,3.3,5.7,5.4,9.6,5.9c0.6,0.1,1.1,0.1,1.7,0.1c3.3,0,6.5-1.2,9-3.5l84.5-76.1c5.5-5,6-13.5,1-19.1 \r
+    c-5-5.5-13.5-6-19.1-1l-56.1,50.7v-1c0-101.9,82.8-184.7,184.6-184.7s184.7,82.8,184.7,184.7s-82.8,184.7-184.6,184.7 \r
+    c-49.3,0-95.7-19.2-130.5-54.1c-5.3-5.3-13.8-5.3-19.1,0c-5.3,5.3-5.3,13.8,0,19.1c40,40,93.1,62,149.6,62 \r
+    c116.6,0,211.6-94.9,211.6-211.7S394.935,33.267,278.235,33.267z`
+      }
+    )
+  }
+);
+an({ ParticleContainer: dn, Particle: hr, Texture: cn, Container: ln, Sprite: un, Graphics: fr });
+const ar = 2, or = 2, ur = 225, lr = 225, Ms = 5, Ws = () => {
+  const [e, t] = Fe(!1), [r, n] = Fe(0), [s, i] = Fe(0), a = rr({
+    from: { rotate: 0 },
+    to: { rotate: s * -360 },
+    config: { duration: 500, easing: (f) => 1 - Math.pow(1 - f, 3) }
+    // 1 second linear spin
+  }), u = rr({
+    opacity: e ? 1 : 0,
+    scale: e ? 1 : 0.5,
+    config: { tension: 150, friction: 14 }
+  }), d = ir(qs), l = ir("button"), m = () => {
+    n((f) => f + 1), i((f) => f + 1);
+  };
+  return /* @__PURE__ */ D.jsxs("div", { className: "flex flex-col items-center justify-center w-full h-full", children: [
+    /* @__PURE__ */ D.jsx(
+      on,
+      {
+        antialias: !1,
+        width: ur * ar,
+        height: lr * or,
+        className: "transition-all image-pixelated md:w-full max-w-max w-72 mb-8",
+        backgroundAlpha: 0,
+        onInit: () => t(!0),
+        children: /* @__PURE__ */ D.jsx(
+          Us,
+          {
+            gridCols: ar,
+            gridRows: or,
+            cellWidth: ur,
+            cellHeight: lr,
+            gridDepth: Ms
+          },
+          r
+        )
+      }
+    ),
+    e && /* @__PURE__ */ D.jsx(
+      l,
+      {
+        style: u,
+        className: "p-4",
+        onClick: m,
+        children: /* @__PURE__ */ D.jsx(
+          d,
+          {
+            width: 36,
+            height: 36,
+            className: "hover:opacity-100 opacity-25",
+            style: {
+              rotate: a.rotate.to((f) => `${f}deg`)
+            }
+          }
+        )
+      }
+    )
+  ] });
+};
 export {
-  f as default
+  Ws as default
 };
 //# sourceMappingURL=recursive-grid.es.js.map