@clubmed/trident-ui 1.3.1-beta.2 → 1.4.0-beta.1

package/hooks/useSafeBoop.js

@@ -1,68 +1,2233 @@
-import { useState as f, useCallback as H, useEffect as c } from "react";
-import { useSpring as J } from "@react-spring/web";
-var K = "(prefers-reduced-motion: no-preference)", N = function() {
-  return typeof window > "u" ? !0 : !window.matchMedia(K).matches;
-}, O = function() {
-  var r = f(N), e = r[0], t = r[1];
-  return c(function() {
-    var n = window.matchMedia("(prefers-reduced-motion: no-preference)"), o = function(a) {
-      t(!a.matches);
+import * as st from "react";
+import { useState as le, useRef as H, useEffect as B, useLayoutEffect as Fi, forwardRef as Ci, useCallback as Ht, useContext as Wt, useMemo as Ae } from "react";
+import { unstable_batchedUpdates as Ei } from "react-dom";
+var Oi = Object.defineProperty, qi = (e, t) => {
+  for (var i in t)
+    Oi(e, i, { get: t[i], enumerable: !0 });
+}, O = {};
+qi(O, {
+  assign: () => $i,
+  colors: () => L,
+  createStringInterpolator: () => ft,
+  skipAnimation: () => ii,
+  to: () => ti,
+  willAdvance: () => ht
+});
+var at = we(), g = (e) => be(e, at), ot = we();
+g.write = (e) => be(e, ot);
+var Ee = we();
+g.onStart = (e) => be(e, Ee);
+var ut = we();
+g.onFrame = (e) => be(e, ut);
+var ct = we();
+g.onFinish = (e) => be(e, ct);
+var K = [];
+g.setTimeout = (e, t) => {
+  const i = g.now() + t, n = () => {
+    const s = K.findIndex((a) => a.cancel == n);
+    ~s && K.splice(s, 1), M -= ~s ? 1 : 0;
+  }, r = { time: i, handler: e, cancel: n };
+  return K.splice(Xt(i), 0, r), M += 1, Zt(), r;
+};
+var Xt = (e) => ~(~K.findIndex((t) => t.time > e) || ~K.length);
+g.cancel = (e) => {
+  Ee.delete(e), ut.delete(e), ct.delete(e), at.delete(e), ot.delete(e);
+};
+g.sync = (e) => {
+  We = !0, g.batchedUpdates(e), We = !1;
+};
+g.throttle = (e) => {
+  let t;
+  function i() {
+    try {
+      e(...t);
+    } finally {
+      t = null;
+    }
+  }
+  function n(...r) {
+    t = r, g.onStart(i);
+  }
+  return n.handler = e, n.cancel = () => {
+    Ee.delete(i), t = null;
+  }, n;
+};
+var lt = typeof window < "u" ? window.requestAnimationFrame : (
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  () => {
+  }
+);
+g.use = (e) => lt = e;
+g.now = typeof performance < "u" ? () => performance.now() : Date.now;
+g.batchedUpdates = (e) => e();
+g.catch = console.error;
+g.frameLoop = "always";
+g.advance = () => {
+  g.frameLoop !== "demand" ? console.warn(
+    "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"
+  ) : Jt();
+};
+var Q = -1, M = 0, We = !1;
+function be(e, t) {
+  We ? (t.delete(e), e(0)) : (t.add(e), Zt());
+}
+function Zt() {
+  Q < 0 && (Q = 0, g.frameLoop !== "demand" && lt(Kt));
+}
+function Ui() {
+  Q = -1;
+}
+function Kt() {
+  ~Q && (lt(Kt), g.batchedUpdates(Jt));
+}
+function Jt() {
+  const e = Q;
+  Q = g.now();
+  const t = Xt(Q);
+  if (t && (ei(K.splice(0, t), (i) => i.handler()), M -= t), !M) {
+    Ui();
+    return;
+  }
+  Ee.flush(), at.flush(e ? Math.min(64, Q - e) : 16.667), ut.flush(), ot.flush(), ct.flush();
+}
+function we() {
+  let e = /* @__PURE__ */ new Set(), t = e;
+  return {
+    add(i) {
+      M += t == e && !e.has(i) ? 1 : 0, e.add(i);
+    },
+    delete(i) {
+      return M -= t == e && e.has(i) ? 1 : 0, e.delete(i);
+    },
+    flush(i) {
+      t.size && (e = /* @__PURE__ */ new Set(), M -= t.size, ei(t, (n) => n(i) && e.add(n)), M += e.size, t = e);
+    }
+  };
+}
+function ei(e, t) {
+  e.forEach((i) => {
+    try {
+      t(i);
+    } catch (n) {
+      g.catch(n);
+    }
+  });
+}
+function Xe() {
+}
+var ji = (e, t, i) => Object.defineProperty(e, t, { value: i, writable: !0, configurable: !0 }), o = {
+  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 z(e, t) {
+  if (o.arr(e)) {
+    if (!o.arr(t) || e.length !== t.length)
+      return !1;
+    for (let i = 0; i < e.length; i++)
+      if (e[i] !== t[i])
+        return !1;
+    return !0;
+  }
+  return e === t;
+}
+var P = (e, t) => e.forEach(t);
+function j(e, t, i) {
+  if (o.arr(e)) {
+    for (let n = 0; n < e.length; n++)
+      t.call(i, e[n], `${n}`);
+    return;
+  }
+  for (const n in e)
+    e.hasOwnProperty(n) && t.call(i, e[n], n);
+}
+var I = (e) => o.und(e) ? [] : o.arr(e) ? e : [e];
+function ae(e, t) {
+  if (e.size) {
+    const i = Array.from(e);
+    e.clear(), P(i, t);
+  }
+}
+var se = (e, ...t) => ae(e, (i) => i(...t)), dt = () => typeof window > "u" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent), ft, ti, L = null, ii = !1, ht = Xe, $i = (e) => {
+  e.to && (ti = e.to), e.now && (g.now = e.now), e.colors !== void 0 && (L = e.colors), e.skipAnimation != null && (ii = e.skipAnimation), e.createStringInterpolator && (ft = e.createStringInterpolator), e.requestAnimationFrame && g.use(e.requestAnimationFrame), e.batchedUpdates && (g.batchedUpdates = e.batchedUpdates), e.willAdvance && (ht = e.willAdvance), e.frameLoop && (g.frameLoop = e.frameLoop);
+}, oe = /* @__PURE__ */ new Set(), V = [], Me = [], Te = 0, Oe = {
+  get idle() {
+    return !oe.size && !V.length;
+  },
+  /** Advance the given animation on every frame until idle. */
+  start(e) {
+    Te > e.priority ? (oe.add(e), g.onStart(zi)) : (ni(e), g(Ze));
+  },
+  /** Advance all animations by the given time. */
+  advance: Ze,
+  /** Call this when an animation's priority changes. */
+  sort(e) {
+    if (Te)
+      g.onFrame(() => Oe.sort(e));
+    else {
+      const t = V.indexOf(e);
+      ~t && (V.splice(t, 1), ri(e));
+    }
+  },
+  /**
+   * Clear all animations. For testing purposes.
+   *
+   * ☠️ Never call this from within the frameloop.
+   */
+  clear() {
+    V = [], oe.clear();
+  }
+};
+function zi() {
+  oe.forEach(ni), oe.clear(), g(Ze);
+}
+function ni(e) {
+  V.includes(e) || ri(e);
+}
+function ri(e) {
+  V.splice(
+    Di(V, (t) => t.priority > e.priority),
+    0,
+    e
+  );
+}
+function Ze(e) {
+  const t = Me;
+  for (let i = 0; i < V.length; i++) {
+    const n = V[i];
+    Te = n.priority, n.idle || (ht(n), n.advance(e), n.idle || t.push(n));
+  }
+  return Te = 0, Me = V, Me.length = 0, V = t, V.length > 0;
+}
+function Di(e, t) {
+  const i = e.findIndex(t);
+  return i < 0 ? e.length : i;
+}
+var Ni = {
+  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
+}, E = "[-+]?\\d*\\.?\\d+", Ve = E + "%";
+function qe(...e) {
+  return "\\(\\s*(" + e.join(")\\s*,\\s*(") + ")\\s*\\)";
+}
+var Qi = new RegExp("rgb" + qe(E, E, E)), Mi = new RegExp("rgba" + qe(E, E, E, E)), Li = new RegExp("hsl" + qe(E, Ve, Ve)), Bi = new RegExp(
+  "hsla" + qe(E, Ve, Ve, E)
+), 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})$/, Hi = /^#([0-9a-fA-F]{6})$/, Wi = /^#([0-9a-fA-F]{8})$/;
+function Xi(e) {
+  let t;
+  return typeof e == "number" ? e >>> 0 === e && e >= 0 && e <= 4294967295 ? e : null : (t = Hi.exec(e)) ? parseInt(t[1] + "ff", 16) >>> 0 : L && L[e] !== void 0 ? L[e] : (t = Qi.exec(e)) ? (Z(t[1]) << 24 | // r
+  Z(t[2]) << 16 | // g
+  Z(t[3]) << 8 | // b
+  255) >>> // a
+  0 : (t = Mi.exec(e)) ? (Z(t[1]) << 24 | // r
+  Z(t[2]) << 16 | // g
+  Z(t[3]) << 8 | // b
+  Tt(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 = Wi.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 = Li.exec(e)) ? (kt(
+    It(t[1]),
+    // h
+    Re(t[2]),
+    // s
+    Re(t[3])
+    // l
+  ) | 255) >>> // a
+  0 : (t = Bi.exec(e)) ? (kt(
+    It(t[1]),
+    // h
+    Re(t[2]),
+    // s
+    Re(t[3])
+    // l
+  ) | Tt(t[4])) >>> // a
+  0 : null;
+}
+function Le(e, t, i) {
+  return i < 0 && (i += 1), i > 1 && (i -= 1), i < 1 / 6 ? e + (t - e) * 6 * i : i < 1 / 2 ? t : i < 2 / 3 ? e + (t - e) * (2 / 3 - i) * 6 : e;
+}
+function kt(e, t, i) {
+  const n = i < 0.5 ? i * (1 + t) : i + t - i * t, r = 2 * i - n, s = Le(r, n, e + 1 / 3), a = Le(r, n, e), u = Le(r, n, e - 1 / 3);
+  return Math.round(s * 255) << 24 | Math.round(a * 255) << 16 | Math.round(u * 255) << 8;
+}
+function Z(e) {
+  const t = parseInt(e, 10);
+  return t < 0 ? 0 : t > 255 ? 255 : t;
+}
+function It(e) {
+  return (parseFloat(e) % 360 + 360) % 360 / 360;
+}
+function Tt(e) {
+  const t = parseFloat(e);
+  return t < 0 ? 0 : t > 1 ? 255 : Math.round(t * 255);
+}
+function Re(e) {
+  const t = parseFloat(e);
+  return t < 0 ? 0 : t > 100 ? 1 : t / 100;
+}
+function Vt(e) {
+  let t = Xi(e);
+  if (t === null)
+    return e;
+  t = t || 0;
+  const i = (t & 4278190080) >>> 24, n = (t & 16711680) >>> 16, r = (t & 65280) >>> 8, s = (t & 255) / 255;
+  return `rgba(${i}, ${n}, ${r}, ${s})`;
+}
+var de = (e, t, i) => {
+  if (o.fun(e))
+    return e;
+  if (o.arr(e))
+    return de({
+      range: e,
+      output: t,
+      extrapolate: i
+    });
+  if (o.str(e.output[0]))
+    return ft(e);
+  const n = e, r = n.output, s = n.range || [0, 1], a = n.extrapolateLeft || n.extrapolate || "extend", u = n.extrapolateRight || n.extrapolate || "extend", d = n.easing || ((c) => c);
+  return (c) => {
+    const h = Ki(c, s);
+    return Zi(
+      c,
+      s[h],
+      s[h + 1],
+      r[h],
+      r[h + 1],
+      d,
+      a,
+      u,
+      n.map
+    );
+  };
+};
+function Zi(e, t, i, n, r, s, a, u, d) {
+  let c = d ? d(e) : e;
+  if (c < t) {
+    if (a === "identity")
+      return c;
+    a === "clamp" && (c = t);
+  }
+  if (c > i) {
+    if (u === "identity")
+      return c;
+    u === "clamp" && (c = i);
+  }
+  return n === r ? n : t === i ? e <= t ? n : r : (t === -1 / 0 ? c = -c : i === 1 / 0 ? c = c - t : c = (c - t) / (i - t), c = s(c), n === -1 / 0 ? c = -c : r === 1 / 0 ? c = c + n : c = c * (r - n) + n, c);
+}
+function Ki(e, t) {
+  for (var i = 1; i < t.length - 1 && !(t[i] >= e); ++i)
+    ;
+  return i - 1;
+}
+var Ji = {
+  linear: (e) => e
+}, fe = Symbol.for("FluidValue.get"), ee = Symbol.for("FluidValue.observers"), T = (e) => !!(e && e[fe]), k = (e) => e && e[fe] ? e[fe]() : e, Ft = (e) => e[ee] || null;
+function en(e, t) {
+  e.eventObserved ? e.eventObserved(t) : e(t);
+}
+function he(e, t) {
+  const i = e[ee];
+  i && i.forEach((n) => {
+    en(n, t);
+  });
+}
+var si = class {
+  constructor(e) {
+    if (!e && !(e = this.get))
+      throw Error("Unknown getter");
+    tn(this, e);
+  }
+}, tn = (e, t) => ai(e, fe, t);
+function te(e, t) {
+  if (e[fe]) {
+    let i = e[ee];
+    i || ai(e, ee, i = /* @__PURE__ */ new Set()), i.has(t) || (i.add(t), e.observerAdded && e.observerAdded(i.size, t));
+  }
+  return t;
+}
+function me(e, t) {
+  const i = e[ee];
+  if (i && i.has(t)) {
+    const n = i.size - 1;
+    n ? i.delete(t) : e[ee] = null, e.observerRemoved && e.observerRemoved(n, t);
+  }
+}
+var ai = (e, t, i) => Object.defineProperty(e, t, {
+  value: i,
+  writable: !0,
+  configurable: !0
+}), ke = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, nn = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi, Ct = new RegExp(`(${ke.source})(%|[a-z]+)`, "i"), rn = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, Ue = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/, oi = (e) => {
+  const [t, i] = sn(e);
+  if (!t || dt())
+    return e;
+  const n = window.getComputedStyle(document.documentElement).getPropertyValue(t);
+  if (n)
+    return n.trim();
+  if (i && i.startsWith("--")) {
+    const r = window.getComputedStyle(document.documentElement).getPropertyValue(i);
+    return r || e;
+  } else {
+    if (i && Ue.test(i))
+      return oi(i);
+    if (i)
+      return i;
+  }
+  return e;
+}, sn = (e) => {
+  const t = Ue.exec(e);
+  if (!t)
+    return [,];
+  const [, i, n] = t;
+  return [i, n];
+}, Be, an = (e, t, i, n, r) => `rgba(${Math.round(t)}, ${Math.round(i)}, ${Math.round(n)}, ${r})`, ui = (e) => {
+  Be || (Be = L ? (
+    // match color names, ignore partial matches
+    new RegExp(`(${Object.keys(L).join("|")})(?!\\w)`, "g")
+  ) : (
+    // never match
+    /^\b$/
+  ));
+  const t = e.output.map((s) => k(s).replace(Ue, oi).replace(nn, Vt).replace(Be, Vt)), i = t.map((s) => s.match(ke).map(Number)), r = i[0].map(
+    (s, a) => i.map((u) => {
+      if (!(a in u))
+        throw Error('The arity of each "output" value must be equal');
+      return u[a];
+    })
+  ).map(
+    (s) => de({ ...e, output: s })
+  );
+  return (s) => {
+    const a = !Ct.test(t[0]) && t.find((d) => Ct.test(d))?.replace(ke, "");
+    let u = 0;
+    return t[0].replace(
+      ke,
+      () => `${r[u++](s)}${a || ""}`
+    ).replace(rn, an);
+  };
+}, mt = "react-spring: ", ci = (e) => {
+  const t = e;
+  let i = !1;
+  if (typeof t != "function")
+    throw new TypeError(`${mt}once requires a function parameter`);
+  return (...n) => {
+    i || (t(...n), i = !0);
+  };
+}, on = ci(console.warn);
+function un() {
+  on(
+    `${mt}The "interpolate" function is deprecated in v9 (use "to" instead)`
+  );
+}
+var cn = ci(console.warn);
+function ln() {
+  cn(
+    `${mt}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 je(e) {
+  return o.str(e) && (e[0] == "#" || /\d/.test(e) || // Do not identify a CSS variable as an AnimatedString if its SSR
+  !dt() && Ue.test(e) || e in (L || {}));
+}
+var pt = dt() ? B : Fi, dn = () => {
+  const e = H(!1);
+  return pt(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), e;
+};
+function li() {
+  const e = le()[1], t = dn();
+  return () => {
+    t.current && e(Math.random());
+  };
+}
+function fn(e, t) {
+  const [i] = le(
+    () => ({
+      inputs: t,
+      result: e()
+    })
+  ), n = H(), r = n.current;
+  let s = r;
+  return s ? t && s.inputs && hn(t, s.inputs) || (s = {
+    inputs: t,
+    result: e()
+  }) : s = i, B(() => {
+    n.current = s, r == i && (i.inputs = i.result = void 0);
+  }, [s]), s.result;
+}
+function hn(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (let i = 0; i < e.length; i++)
+    if (e[i] !== t[i])
+      return !1;
+  return !0;
+}
+var di = (e) => B(e, mn), mn = [];
+function Et(e) {
+  const t = H();
+  return B(() => {
+    t.current = e;
+  }), t.current;
+}
+var pe = Symbol.for("Animated:node"), pn = (e) => !!e && e[pe] === e, U = (e) => e && e[pe], gt = (e, t) => ji(e, pe, t), $e = (e) => e && e[pe] && e[pe].getPayload(), fi = class {
+  constructor() {
+    gt(this, this);
+  }
+  /** Get every `AnimatedValue` used by this node. */
+  getPayload() {
+    return this.payload || [];
+  }
+}, Pe = class extends fi {
+  constructor(e) {
+    super(), this._value = e, this.done = !0, this.durationProgress = 0, o.num(this._value) && (this.lastPosition = this._value);
+  }
+  /** @internal */
+  static create(e) {
+    return new Pe(e);
+  }
+  getPayload() {
+    return [this];
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(e, t) {
+    return o.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, o.num(this._value) && (this.elapsedTime = 0, this.durationProgress = 0, this.lastPosition = this._value, e && (this.lastVelocity = null), this.v0 = null);
+  }
+}, ge = class extends Pe {
+  constructor(e) {
+    super(0), this._string = null, this._toString = de({
+      output: [e, e]
+    });
+  }
+  /** @internal */
+  static create(e) {
+    return new ge(e);
+  }
+  getValue() {
+    const e = this._string;
+    return e ?? (this._string = this._toString(this._value));
+  }
+  setValue(e) {
+    if (o.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 = de({
+      output: [this.getValue(), e]
+    })), this._value = 0, super.reset();
+  }
+}, Fe = { dependencies: null }, ze = class extends fi {
+  constructor(e) {
+    super(), this.source = e, this.setValue(e);
+  }
+  getValue(e) {
+    const t = {};
+    return j(this.source, (i, n) => {
+      pn(i) ? t[n] = i.getValue(e) : T(i) ? t[n] = k(i) : e || (t[n] = i);
+    }), t;
+  }
+  /** Replace the raw object data */
+  setValue(e) {
+    this.source = e, this.payload = this._makePayload(e);
+  }
+  reset() {
+    this.payload && P(this.payload, (e) => e.reset());
+  }
+  /** Create a payload set. */
+  _makePayload(e) {
+    if (e) {
+      const t = /* @__PURE__ */ new Set();
+      return j(e, this._addToPayload, t), Array.from(t);
+    }
+  }
+  /** Add to a payload set. */
+  _addToPayload(e) {
+    Fe.dependencies && T(e) && Fe.dependencies.add(e);
+    const t = $e(e);
+    t && P(t, (i) => this.add(i));
+  }
+}, hi = class extends ze {
+  constructor(e) {
+    super(e);
+  }
+  /** @internal */
+  static create(e) {
+    return new hi(e);
+  }
+  getValue() {
+    return this.source.map((e) => e.getValue());
+  }
+  setValue(e) {
+    const t = this.getPayload();
+    return e.length == t.length ? t.map((i, n) => i.setValue(e[n])).some(Boolean) : (super.setValue(e.map(gn)), !0);
+  }
+};
+function gn(e) {
+  return (je(e) ? ge : Pe).create(e);
+}
+function Ke(e) {
+  const t = U(e);
+  return t ? t.constructor : o.arr(e) ? hi : je(e) ? ge : Pe;
+}
+var Ot = (e, t) => {
+  const i = (
+    // Function components must use "forwardRef" to avoid being
+    // re-rendered on every animation frame.
+    !o.fun(e) || e.prototype && e.prototype.isReactComponent
+  );
+  return Ci((n, r) => {
+    const s = H(null), a = i && // eslint-disable-next-line react-hooks/rules-of-hooks
+    Ht(
+      (y) => {
+        s.current = _n(r, y);
+      },
+      [r]
+    ), [u, d] = yn(n, t), c = li(), h = () => {
+      const y = s.current;
+      if (i && !y)
+        return;
+      (y ? t.applyAnimatedValues(y, u.getValue(!0)) : !1) === !1 && c();
+    }, l = new vn(h, d), v = H();
+    pt(() => (v.current = l, P(d, (y) => te(y, l)), () => {
+      v.current && (P(
+        v.current.deps,
+        (y) => me(y, v.current)
+      ), g.cancel(v.current.update));
+    })), B(h, []), di(() => () => {
+      const y = v.current;
+      P(y.deps, (m) => me(m, y));
+    });
+    const b = t.getComponentProps(u.getValue());
+    return /* @__PURE__ */ st.createElement(e, { ...b, ref: a });
+  });
+}, vn = class {
+  constructor(e, t) {
+    this.update = e, this.deps = t;
+  }
+  eventObserved(e) {
+    e.type == "change" && g.write(this.update);
+  }
+};
+function yn(e, t) {
+  const i = /* @__PURE__ */ new Set();
+  return Fe.dependencies = i, e.style && (e = {
+    ...e,
+    style: t.createAnimatedStyle(e.style)
+  }), e = new ze(e), Fe.dependencies = null, [e, i];
+}
+function _n(e, t) {
+  return e && (o.fun(e) ? e(t) : e.current = t), t;
+}
+var qt = Symbol.for("AnimatedComponent"), bn = (e, {
+  applyAnimatedValues: t = () => !1,
+  createAnimatedStyle: i = (r) => new ze(r),
+  getComponentProps: n = (r) => r
+} = {}) => {
+  const r = {
+    applyAnimatedValues: t,
+    createAnimatedStyle: i,
+    getComponentProps: n
+  }, s = (a) => {
+    const u = Ut(a) || "Anonymous";
+    return o.str(a) ? a = s[a] || (s[a] = Ot(a, r)) : a = a[qt] || (a[qt] = Ot(a, r)), a.displayName = `Animated(${u})`, a;
+  };
+  return j(e, (a, u) => {
+    o.arr(e) && (u = Ut(a)), s[u] = s(a);
+  }), {
+    animated: s
+  };
+}, Ut = (e) => o.str(e) ? e : e && o.str(e.displayName) ? e.displayName : o.fun(e) && e.name || null;
+function Y(e, ...t) {
+  return o.fun(e) ? e(...t) : e;
+}
+var ue = (e, t) => e === !0 || !!(t && e && (o.fun(e) ? e(t) : I(e).includes(t))), mi = (e, t) => o.obj(e) ? t && e[t] : e, pi = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, wn = (e) => e, vt = (e, t = wn) => {
+  let i = Pn;
+  e.default && e.default !== !0 && (e = e.default, i = Object.keys(e));
+  const n = {};
+  for (const r of i) {
+    const s = t(e[r], r);
+    o.und(s) || (n[r] = s);
+  }
+  return n;
+}, Pn = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+], Sn = {
+  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 xn(e) {
+  const t = {};
+  let i = 0;
+  if (j(e, (n, r) => {
+    Sn[r] || (t[r] = n, i++);
+  }), i)
+    return t;
+}
+function gi(e) {
+  const t = xn(e);
+  if (t) {
+    const i = { to: t };
+    return j(e, (n, r) => r in t || (i[r] = n)), i;
+  }
+  return { ...e };
+}
+function ve(e) {
+  return e = k(e), o.arr(e) ? e.map(ve) : je(e) ? O.createStringInterpolator({
+    range: [0, 1],
+    output: [e, e]
+  })(1) : e;
+}
+function An(e) {
+  for (const t in e)
+    return !0;
+  return !1;
+}
+function Je(e) {
+  return o.fun(e) || o.arr(e) && o.obj(e[0]);
+}
+function Rn(e, t) {
+  e.ref?.delete(e), t?.delete(e);
+}
+function kn(e, t) {
+  t && e.ref !== t && (e.ref?.delete(e), t.add(e), e.ref = t);
+}
+var In = {
+  default: { tension: 170, friction: 26 }
+}, et = {
+  ...In.default,
+  mass: 1,
+  damping: 1,
+  easing: Ji.linear,
+  clamp: !1
+}, Tn = class {
+  constructor() {
+    this.velocity = 0, Object.assign(this, et);
+  }
+};
+function Vn(e, t, i) {
+  i && (i = { ...i }, jt(i, t), t = { ...i, ...t }), jt(e, t), Object.assign(e, t);
+  for (const a in et)
+    e[a] == null && (e[a] = et[a]);
+  let { frequency: n, damping: r } = e;
+  const { mass: s } = e;
+  return o.und(n) || (n < 0.01 && (n = 0.01), r < 0 && (r = 0), e.tension = Math.pow(2 * Math.PI / n, 2) * s, e.friction = 4 * Math.PI * r * s / n), e;
+}
+function jt(e, t) {
+  if (!o.und(t.decay))
+    e.duration = void 0;
+  else {
+    const i = !o.und(t.tension) || !o.und(t.friction);
+    (i || !o.und(t.frequency) || !o.und(t.damping) || !o.und(t.mass)) && (e.duration = void 0, e.decay = void 0), i && (e.frequency = void 0);
+  }
+}
+var $t = [], Fn = class {
+  constructor() {
+    this.changed = !1, this.values = $t, this.toValues = null, this.fromValues = $t, this.config = new Tn(), this.immediate = !1;
+  }
+};
+function vi(e, { key: t, props: i, defaultProps: n, state: r, actions: s }) {
+  return new Promise((a, u) => {
+    let d, c, h = ue(i.cancel ?? n?.cancel, t);
+    if (h)
+      b();
+    else {
+      o.und(i.pause) || (r.paused = ue(i.pause, t));
+      let y = n?.pause;
+      y !== !0 && (y = r.paused || ue(y, t)), d = Y(i.delay || 0, t), y ? (r.resumeQueue.add(v), s.pause()) : (s.resume(), v());
+    }
+    function l() {
+      r.resumeQueue.add(v), r.timeouts.delete(c), c.cancel(), d = c.time - g.now();
+    }
+    function v() {
+      d > 0 && !O.skipAnimation ? (r.delayed = !0, c = g.setTimeout(b, d), r.pauseQueue.add(l), r.timeouts.add(c)) : b();
+    }
+    function b() {
+      r.delayed && (r.delayed = !1), r.pauseQueue.delete(l), r.timeouts.delete(c), e <= (r.cancelId || 0) && (h = !0);
+      try {
+        s.start({ ...i, callId: e, cancel: h }, a);
+      } catch (y) {
+        u(y);
+      }
+    }
+  });
+}
+var yt = (e, t) => t.length == 1 ? t[0] : t.some((i) => i.cancelled) ? J(e.get()) : t.every((i) => i.noop) ? yi(e.get()) : C(
+  e.get(),
+  t.every((i) => i.finished)
+), yi = (e) => ({
+  value: e,
+  noop: !0,
+  finished: !0,
+  cancelled: !1
+}), C = (e, t, i = !1) => ({
+  value: e,
+  finished: t,
+  cancelled: i
+}), J = (e) => ({
+  value: e,
+  cancelled: !0,
+  finished: !1
+});
+function _i(e, t, i, n) {
+  const { callId: r, parentId: s, onRest: a } = t, { asyncTo: u, promise: d } = i;
+  return !s && e === u && !t.reset ? d : i.promise = (async () => {
+    i.asyncId = r, i.asyncTo = e;
+    const c = vt(
+      t,
+      (_, f) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        f === "onRest" ? void 0 : _
+      )
+    );
+    let h, l;
+    const v = new Promise(
+      (_, f) => (h = _, l = f)
+    ), b = (_) => {
+      const f = (
+        // The `cancel` prop or `stop` method was used.
+        r <= (i.cancelId || 0) && J(n) || // The async `to` prop was replaced.
+        r !== i.asyncId && C(n, !1)
+      );
+      if (f)
+        throw _.result = f, l(_), _;
+    }, y = (_, f) => {
+      const w = new zt(), p = new Dt();
+      return (async () => {
+        if (O.skipAnimation)
+          throw ye(i), p.result = C(n, !1), l(p), p;
+        b(w);
+        const S = o.obj(_) ? { ..._ } : { ...f, to: _ };
+        S.parentId = r, j(c, (q, A) => {
+          o.und(S[A]) && (S[A] = q);
+        });
+        const x = await n.start(S);
+        return b(w), i.paused && await new Promise((q) => {
+          i.resumeQueue.add(q);
+        }), x;
+      })();
+    };
+    let m;
+    if (O.skipAnimation)
+      return ye(i), C(n, !1);
+    try {
+      let _;
+      o.arr(e) ? _ = (async (f) => {
+        for (const w of f)
+          await y(w);
+      })(e) : _ = Promise.resolve(e(y, n.stop.bind(n))), await Promise.all([_.then(h), v]), m = C(n.get(), !0, !1);
+    } catch (_) {
+      if (_ instanceof zt)
+        m = _.result;
+      else if (_ instanceof Dt)
+        m = _.result;
+      else
+        throw _;
+    } finally {
+      r == i.asyncId && (i.asyncId = s, i.asyncTo = s ? u : void 0, i.promise = s ? d : void 0);
+    }
+    return o.fun(a) && g.batchedUpdates(() => {
+      a(m, n, n.item);
+    }), m;
+  })();
+}
+function ye(e, t) {
+  ae(e.timeouts, (i) => i.cancel()), e.pauseQueue.clear(), e.resumeQueue.clear(), e.asyncId = e.asyncTo = e.promise = void 0, t && (e.cancelId = t);
+}
+var zt = 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."
+    );
+  }
+}, Dt = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+}, tt = (e) => e instanceof _t, Cn = 1, _t = class extends si {
+  constructor() {
+    super(...arguments), this.id = Cn++, 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 = U(this);
+    return e && e.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...e) {
+    return O.to(this, e);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...e) {
+    return un(), O.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) {
+    he(this, {
+      type: "change",
+      parent: this,
+      value: e,
+      idle: t
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(e) {
+    this.idle || Oe.sort(this), he(this, {
+      type: "priority",
+      parent: this,
+      priority: e
+    });
+  }
+}, W = Symbol.for("SpringPhase"), bi = 1, it = 2, nt = 4, Ge = (e) => (e[W] & bi) > 0, N = (e) => (e[W] & it) > 0, ie = (e) => (e[W] & nt) > 0, Nt = (e, t) => t ? e[W] |= it | bi : e[W] &= ~it, Qt = (e, t) => t ? e[W] |= nt : e[W] &= ~nt, En = class extends _t {
+  constructor(e, t) {
+    if (super(), this.animation = new Fn(), 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, !o.und(e) || !o.und(t)) {
+      const i = o.obj(e) ? { ...e } : { ...t, from: e };
+      o.und(i.default) && (i.default = !0), this.start(i);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(N(this) || this._state.asyncTo) || ie(this);
+  }
+  get goal() {
+    return k(this.animation.to);
+  }
+  get velocity() {
+    const e = U(this);
+    return e instanceof Pe ? e.lastVelocity || 0 : e.getPayload().map((t) => t.lastVelocity || 0);
+  }
+  /**
+   * When true, this value has been animated at least once.
+   */
+  get hasAnimated() {
+    return Ge(this);
+  }
+  /**
+   * When true, this value has an unfinished animation,
+   * which is either active or paused.
+   */
+  get isAnimating() {
+    return N(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return ie(this);
+  }
+  /**
+   *
+   *
+   */
+  get isDelayed() {
+    return this._state.delayed;
+  }
+  /** Advance the current animation by a number of milliseconds */
+  advance(e) {
+    let t = !0, i = !1;
+    const n = this.animation;
+    let { toValues: r } = n;
+    const { config: s } = n, a = $e(n.to);
+    !a && T(n.to) && (r = I(k(n.to))), n.values.forEach((c, h) => {
+      if (c.done)
+        return;
+      const l = (
+        // Animated strings always go from 0 to 1.
+        c.constructor == ge ? 1 : a ? a[h].lastPosition : r[h]
+      );
+      let v = n.immediate, b = l;
+      if (!v) {
+        if (b = c.lastPosition, s.tension <= 0) {
+          c.done = !0;
+          return;
+        }
+        let y = c.elapsedTime += e;
+        const m = n.fromValues[h], _ = c.v0 != null ? c.v0 : c.v0 = o.arr(s.velocity) ? s.velocity[h] : s.velocity;
+        let f;
+        const w = s.precision || (m == l ? 5e-3 : Math.min(1, Math.abs(l - m) * 1e-3));
+        if (o.und(s.duration))
+          if (s.decay) {
+            const p = s.decay === !0 ? 0.998 : s.decay, S = Math.exp(-(1 - p) * y);
+            b = m + _ / (1 - p) * (1 - S), v = Math.abs(c.lastPosition - b) <= w, f = _ * S;
+          } else {
+            f = c.lastVelocity == null ? _ : c.lastVelocity;
+            const p = s.restVelocity || w / 10, S = s.clamp ? 0 : s.bounce, x = !o.und(S), q = m == l ? c.v0 > 0 : m < l;
+            let A, G = !1;
+            const R = 1, D = Math.ceil(e / R);
+            for (let F = 0; F < D && (A = Math.abs(f) > p, !(!A && (v = Math.abs(l - b) <= w, v))); ++F) {
+              x && (G = b == l || b > l == q, G && (f = -f * S, b = l));
+              const $ = -s.tension * 1e-6 * (b - l), X = -s.friction * 1e-3 * f, Se = ($ + X) / s.mass;
+              f = f + Se * R, b = b + f * R;
+            }
+          }
+        else {
+          let p = 1;
+          s.duration > 0 && (this._memoizedDuration !== s.duration && (this._memoizedDuration = s.duration, c.durationProgress > 0 && (c.elapsedTime = s.duration * c.durationProgress, y = c.elapsedTime += e)), p = (s.progress || 0) + y / this._memoizedDuration, p = p > 1 ? 1 : p < 0 ? 0 : p, c.durationProgress = p), b = m + s.easing(p) * (l - m), f = (b - c.lastPosition) / e, v = p == 1;
+        }
+        c.lastVelocity = f, Number.isNaN(b) && (console.warn("Got NaN while animating:", this), v = !0);
+      }
+      a && !a[h].done && (v = !1), v ? c.done = !0 : t = !1, c.setValue(b, s.round) && (i = !0);
+    });
+    const u = U(this), d = u.getValue();
+    if (t) {
+      const c = k(n.to);
+      (d !== c || i) && !s.decay ? (u.setValue(c), this._onChange(c)) : i && s.decay && this._onChange(d), this._stop();
+    } else i && this._onChange(d);
+  }
+  /** Set the current value, while stopping the current animation */
+  set(e) {
+    return g.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 (N(this)) {
+      const { to: e, config: t } = this.animation;
+      g.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 i;
+    return o.und(e) ? (i = this.queue || [], this.queue = []) : i = [o.obj(e) ? e : { ...t, to: e }], Promise.all(
+      i.map((n) => this._update(n))
+    ).then((n) => yt(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()), ye(this._state, e && this._lastCallId), g.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: i, from: n } = e;
+    i = o.obj(i) ? i[t] : i, (i == null || Je(i)) && (i = void 0), n = o.obj(n) ? n[t] : n, n == null && (n = void 0);
+    const r = { to: i, from: n };
+    return Ge(this) || (e.reverse && ([i, n] = [n, i]), n = k(n), o.und(n) ? U(this) || this._set(i) : this._set(n)), r;
+  }
+  /** Every update is processed by this method before merging. */
+  _update({ ...e }, t) {
+    const { key: i, defaultProps: n } = this;
+    e.default && Object.assign(
+      n,
+      vt(
+        e,
+        (a, u) => /^on/.test(u) ? mi(a, i) : a
+      )
+    ), Lt(this, e, "onProps"), re(this, "onProps", e, this);
+    const r = 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 s = this._state;
+    return vi(++this._lastCallId, {
+      key: i,
+      props: e,
+      defaultProps: n,
+      state: s,
+      actions: {
+        pause: () => {
+          ie(this) || (Qt(this, !0), se(s.pauseQueue), re(
+            this,
+            "onPause",
+            C(this, ne(this, this.animation.to)),
+            this
+          ));
+        },
+        resume: () => {
+          ie(this) && (Qt(this, !1), N(this) && this._resume(), se(s.resumeQueue), re(
+            this,
+            "onResume",
+            C(this, ne(this, this.animation.to)),
+            this
+          ));
+        },
+        start: this._merge.bind(this, r)
+      }
+    }).then((a) => {
+      if (e.loop && a.finished && !(t && a.noop)) {
+        const u = wi(e);
+        if (u)
+          return this._update(u, !0);
+      }
+      return a;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(e, t, i) {
+    if (t.cancel)
+      return this.stop(!0), i(J(this));
+    const n = !o.und(e.to), r = !o.und(e.from);
+    if (n || r)
+      if (t.callId > this._lastToId)
+        this._lastToId = t.callId;
+      else
+        return i(J(this));
+    const { key: s, defaultProps: a, animation: u } = this, { to: d, from: c } = u;
+    let { to: h = d, from: l = c } = e;
+    r && !n && (!t.default || o.und(h)) && (h = l), t.reverse && ([h, l] = [l, h]);
+    const v = !z(l, c);
+    v && (u.from = l), l = k(l);
+    const b = !z(h, d);
+    b && this._focus(h);
+    const y = Je(t.to), { config: m } = u, { decay: _, velocity: f } = m;
+    (n || r) && (m.velocity = 0), t.config && !y && Vn(
+      m,
+      Y(t.config, s),
+      // Avoid calling the same "config" prop twice.
+      t.config !== a.config ? Y(a.config, s) : void 0
+    );
+    let w = U(this);
+    if (!w || o.und(h))
+      return i(C(this, !0));
+    const p = (
+      // 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.
+      o.und(t.reset) ? r && !t.default : !o.und(l) && ue(t.reset, s)
+    ), S = p ? l : this.get(), x = ve(h), q = o.num(x) || o.arr(x) || je(x), A = !y && (!q || ue(a.immediate || t.immediate, s));
+    if (b) {
+      const F = Ke(h);
+      if (F !== w.constructor)
+        if (A)
+          w = this._set(x);
+        else
+          throw Error(
+            `Cannot animate between ${w.constructor.name} and ${F.name}, as the "to" prop suggests`
+          );
+    }
+    const G = w.constructor;
+    let R = T(h), D = !1;
+    if (!R) {
+      const F = p || !Ge(this) && v;
+      (b || F) && (D = z(ve(S), x), R = !D), (!z(u.immediate, A) && !A || !z(m.decay, _) || !z(m.velocity, f)) && (R = !0);
+    }
+    if (D && N(this) && (u.changed && !p ? R = !0 : R || this._stop(d)), !y && ((R || T(d)) && (u.values = w.getPayload(), u.toValues = T(h) ? null : G == ge ? [1] : I(x)), u.immediate != A && (u.immediate = A, !A && !p && this._set(d)), R)) {
+      const { onRest: F } = u;
+      P(qn, (X) => Lt(this, t, X));
+      const $ = C(this, ne(this, d));
+      se(this._pendingCalls, $), this._pendingCalls.add(i), u.changed && g.batchedUpdates(() => {
+        u.changed = !p, F?.($, this), p ? Y(a.onRest, $) : u.onStart?.($, this);
+      });
+    }
+    p && this._set(S), y ? i(_i(t.to, t, this._state, this)) : R ? this._start() : N(this) && !b ? this._pendingCalls.add(i) : i(yi(S));
+  }
+  /** Update the `animation.to` value, which might be a `FluidValue` */
+  _focus(e) {
+    const t = this.animation;
+    e !== t.to && (Ft(this) && this._detach(), t.to = e, Ft(this) && this._attach());
+  }
+  _attach() {
+    let e = 0;
+    const { to: t } = this.animation;
+    T(t) && (te(t, this), tt(t) && (e = t.priority + 1)), this.priority = e;
+  }
+  _detach() {
+    const { to: e } = this.animation;
+    T(e) && me(e, this);
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(e, t = !0) {
+    const i = k(e);
+    if (!o.und(i)) {
+      const n = U(this);
+      if (!n || !z(i, n.getValue())) {
+        const r = Ke(i);
+        !n || n.constructor != r ? gt(this, r.create(i)) : n.setValue(i), n && g.batchedUpdates(() => {
+          this._onChange(i, t);
+        });
+      }
+    }
+    return U(this);
+  }
+  _onStart() {
+    const e = this.animation;
+    e.changed || (e.changed = !0, re(
+      this,
+      "onStart",
+      C(this, ne(this, e.to)),
+      this
+    ));
+  }
+  _onChange(e, t) {
+    t || (this._onStart(), Y(this.animation.onChange, e, this)), Y(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;
+    U(this).reset(k(e.to)), e.immediate || (e.fromValues = e.values.map((t) => t.lastPosition)), N(this) || (Nt(this, !0), ie(this) || this._resume());
+  }
+  _resume() {
+    O.skipAnimation ? this.finish() : Oe.start(this);
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(e, t) {
+    if (N(this)) {
+      Nt(this, !1);
+      const i = this.animation;
+      P(i.values, (r) => {
+        r.done = !0;
+      }), i.toValues && (i.onChange = i.onPause = i.onResume = void 0), he(this, {
+        type: "idle",
+        parent: this
+      });
+      const n = t ? J(this.get()) : C(this.get(), ne(this, e ?? i.to));
+      se(this._pendingCalls, n), i.changed && (i.changed = !1, re(this, "onRest", n, this));
+    }
+  }
+};
+function ne(e, t) {
+  const i = ve(t), n = ve(e.get());
+  return z(n, i);
+}
+function wi(e, t = e.loop, i = e.to) {
+  const n = Y(t);
+  if (n) {
+    const r = n !== !0 && gi(n), s = (r || e).reverse, a = !r || r.reset;
+    return _e({
+      ...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: !s || Je(i) ? i : 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.
+      ...r
+    });
+  }
+}
+function _e(e) {
+  const { to: t, from: i } = e = gi(e), n = /* @__PURE__ */ new Set();
+  return o.obj(t) && Mt(t, n), o.obj(i) && Mt(i, n), e.keys = n.size ? Array.from(n) : null, e;
+}
+function On(e) {
+  const t = _e(e);
+  return o.und(t.default) && (t.default = vt(t)), t;
+}
+function Mt(e, t) {
+  j(e, (i, n) => i != null && t.add(n));
+}
+var qn = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function Lt(e, t, i) {
+  e.animation[i] = t[i] !== pi(t, i) ? mi(t[i], e.key) : void 0;
+}
+function re(e, t, ...i) {
+  e.animation[t]?.(...i), e.defaultProps[t]?.(...i);
+}
+var Un = ["onStart", "onChange", "onRest"], jn = 1, $n = class {
+  constructor(e, t) {
+    this.id = jn++, 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, i) => e[i] = t.get()), e;
+  }
+  /** Set the current values without animating. */
+  set(e) {
+    for (const t in e) {
+      const i = e[t];
+      o.und(i) || this.springs[t].set(i);
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(e) {
+    return e && this.queue.push(_e(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 = I(e).map(_e) : this.queue = [], this._flush ? this._flush(this, t) : (Ri(this, t), rt(this, t));
+  }
+  /** @internal */
+  stop(e, t) {
+    if (e !== !!e && (t = e), t) {
+      const i = this.springs;
+      P(I(t), (n) => i[n].stop(!!e));
+    } else
+      ye(this._state, this._lastAsyncId), this.each((i) => i.stop(!!e));
+    return this;
+  }
+  /** Freeze the active animation in time */
+  pause(e) {
+    if (o.und(e))
+      this.start({ pause: !0 });
+    else {
+      const t = this.springs;
+      P(I(e), (i) => t[i].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(e) {
+    if (o.und(e))
+      this.start({ pause: !1 });
+    else {
+      const t = this.springs;
+      P(I(e), (i) => t[i].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(e) {
+    j(this.springs, e);
+  }
+  /** @internal Called at the end of every animation frame */
+  _onFrame() {
+    const { onStart: e, onChange: t, onRest: i } = this._events, n = this._active.size > 0, r = this._changed.size > 0;
+    (n && !this._started || r && !this._started) && (this._started = !0, ae(e, ([u, d]) => {
+      d.value = this.get(), u(d, this, this._item);
+    }));
+    const s = !n && this._started, a = r || s && i.size ? this.get() : null;
+    r && t.size && ae(t, ([u, d]) => {
+      d.value = a, u(d, this, this._item);
+    }), s && (this._started = !1, ae(i, ([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;
+    g.onFrame(this._onFrame);
+  }
+};
+function rt(e, t) {
+  return Promise.all(t.map((i) => Pi(e, i))).then(
+    (i) => yt(e, i)
+  );
+}
+async function Pi(e, t, i) {
+  const { keys: n, to: r, from: s, loop: a, onRest: u, onResolve: d } = t, c = o.obj(t.default) && t.default;
+  a && (t.loop = !1), r === !1 && (t.to = null), s === !1 && (t.from = null);
+  const h = o.arr(r) || o.fun(r) ? r : void 0;
+  h ? (t.to = void 0, t.onRest = void 0, c && (c.onRest = void 0)) : P(Un, (m) => {
+    const _ = t[m];
+    if (o.fun(_)) {
+      const f = e._events[m];
+      t[m] = ({ finished: w, cancelled: p }) => {
+        const S = f.get(_);
+        S ? (w || (S.finished = !1), p && (S.cancelled = !0)) : f.set(_, {
+          value: null,
+          finished: w || !1,
+          cancelled: p || !1
+        });
+      }, c && (c[m] = t[m]);
+    }
+  });
+  const l = e._state;
+  t.pause === !l.paused ? (l.paused = t.pause, se(t.pause ? l.pauseQueue : l.resumeQueue)) : l.paused && (t.pause = !0);
+  const v = (n || Object.keys(e.springs)).map(
+    (m) => e.springs[m].start(t)
+  ), b = t.cancel === !0 || pi(t, "cancel") === !0;
+  (h || b && l.asyncId) && v.push(
+    vi(++e._lastAsyncId, {
+      props: t,
+      state: l,
+      actions: {
+        pause: Xe,
+        resume: Xe,
+        start(m, _) {
+          b ? (ye(l, e._lastAsyncId), _(J(e))) : (m.onRest = u, _(
+            _i(
+              h,
+              m,
+              l,
+              e
+            )
+          ));
+        }
+      }
+    })
+  ), l.paused && await new Promise((m) => {
+    l.resumeQueue.add(m);
+  });
+  const y = yt(e, await Promise.all(v));
+  if (a && y.finished && !(i && y.noop)) {
+    const m = wi(t, a, r);
+    if (m)
+      return Ri(e, [m]), Pi(e, m, !0);
+  }
+  return d && g.batchedUpdates(() => d(y, e, e.item)), y;
+}
+function Bt(e, t) {
+  const i = { ...e.springs };
+  return t && P(I(t), (n) => {
+    o.und(n.keys) && (n = _e(n)), o.obj(n.to) || (n = { ...n, to: void 0 }), Ai(i, n, (r) => xi(r));
+  }), Si(e, i), i;
+}
+function Si(e, t) {
+  j(t, (i, n) => {
+    e.springs[n] || (e.springs[n] = i, te(i, e));
+  });
+}
+function xi(e, t) {
+  const i = new En();
+  return i.key = e, t && te(i, t), i;
+}
+function Ai(e, t, i) {
+  t.keys && P(t.keys, (n) => {
+    (e[n] || (e[n] = i(n)))._prepareNode(t);
+  });
+}
+function Ri(e, t) {
+  P(t, (i) => {
+    Ai(e.springs, i, (n) => xi(n, e));
+  });
+}
+var De = ({
+  children: e,
+  ...t
+}) => {
+  const i = Wt(Ce), n = t.pause || !!i.pause, r = t.immediate || !!i.immediate;
+  t = fn(() => ({ pause: n, immediate: r }), [n, r]);
+  const { Provider: s } = Ce;
+  return /* @__PURE__ */ st.createElement(s, { value: t }, e);
+}, Ce = zn(De, {});
+De.Provider = Ce.Provider;
+De.Consumer = Ce.Consumer;
+function zn(e, t) {
+  return Object.assign(e, st.createContext(t)), e.Provider._context = e, e.Consumer._context = e, e;
+}
+var Dn = () => {
+  const e = [], t = function(n) {
+    ln();
+    const r = [];
+    return P(e, (s, a) => {
+      if (o.und(n))
+        r.push(s.start());
+      else {
+        const u = i(n, s, a);
+        u && r.push(s.start(u));
+      }
+    }), r;
+  };
+  t.current = e, t.add = function(n) {
+    e.includes(n) || e.push(n);
+  }, t.delete = function(n) {
+    const r = e.indexOf(n);
+    ~r && e.splice(r, 1);
+  }, t.pause = function() {
+    return P(e, (n) => n.pause(...arguments)), this;
+  }, t.resume = function() {
+    return P(e, (n) => n.resume(...arguments)), this;
+  }, t.set = function(n) {
+    P(e, (r, s) => {
+      const a = o.fun(n) ? n(s, r) : n;
+      a && r.set(a);
+    });
+  }, t.start = function(n) {
+    const r = [];
+    return P(e, (s, a) => {
+      if (o.und(n))
+        r.push(s.start());
+      else {
+        const u = this._getProps(n, s, a);
+        u && r.push(s.start(u));
+      }
+    }), r;
+  }, t.stop = function() {
+    return P(e, (n) => n.stop(...arguments)), this;
+  }, t.update = function(n) {
+    return P(e, (r, s) => r.update(this._getProps(n, r, s))), this;
+  };
+  const i = function(n, r, s) {
+    return o.fun(n) ? n(s, r) : n;
+  };
+  return t._getProps = i, t;
+};
+function Nn(e, t, i) {
+  const n = o.fun(t) && t;
+  n && !i && (i = []);
+  const r = Ae(
+    () => n || arguments.length == 3 ? Dn() : void 0,
+    []
+  ), s = H(0), a = li(), u = Ae(
+    () => ({
+      ctrls: [],
+      queue: [],
+      flush(f, w) {
+        const p = Bt(f, w);
+        return s.current > 0 && !u.queue.length && !Object.keys(p).some((x) => !f.springs[x]) ? rt(f, w) : new Promise((x) => {
+          Si(f, p), u.queue.push(() => {
+            x(rt(f, w));
+          }), a();
+        });
+      }
+    }),
+    []
+  ), d = H([...u.ctrls]), c = [], h = Et(e) || 0;
+  Ae(() => {
+    P(d.current.slice(e, h), (f) => {
+      Rn(f, r), f.stop(!0);
+    }), d.current.length = e, l(h, e);
+  }, [e]), Ae(() => {
+    l(0, Math.min(h, e));
+  }, i);
+  function l(f, w) {
+    for (let p = f; p < w; p++) {
+      const S = d.current[p] || (d.current[p] = new $n(null, u.flush)), x = n ? n(p, S) : t[p];
+      x && (c[p] = On(x));
+    }
+  }
+  const v = d.current.map((f, w) => Bt(f, c[w])), b = Wt(De), y = Et(b), m = b !== y && An(b);
+  pt(() => {
+    s.current++, u.ctrls = d.current;
+    const { queue: f } = u;
+    f.length && (u.queue = [], P(f, (w) => w())), P(d.current, (w, p) => {
+      r?.add(w), m && w.start({ default: b });
+      const S = c[p];
+      S && (kn(w, S.ref), w.ref ? w.queue.push(S) : w.start(S));
+    });
+  }), di(() => () => {
+    P(u.ctrls, (f) => f.stop(!0));
+  });
+  const _ = v.map((f) => ({ ...f }));
+  return r ? [_, r] : _;
+}
+function Qn(e, t) {
+  const i = o.fun(e), [[n], r] = Nn(
+    1,
+    i ? e : [e],
+    i ? [] : t
+  );
+  return i || arguments.length == 2 ? [n, r] : n;
+}
+var Mn = class extends _t {
+  constructor(e, t) {
+    super(), this.source = e, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = de(...t);
+    const i = this._get(), n = Ke(i);
+    gt(this, n.create(i));
+  }
+  advance(e) {
+    const t = this._get(), i = this.get();
+    z(t, i) || (U(this).setValue(t), this._onChange(t, this.idle)), !this.idle && Gt(this._active) && Ye(this);
+  }
+  _get() {
+    const e = o.arr(this.source) ? this.source.map(k) : I(k(this.source));
+    return this.calc(...e);
+  }
+  _start() {
+    this.idle && !Gt(this._active) && (this.idle = !1, P($e(this), (e) => {
+      e.done = !1;
+    }), O.skipAnimation ? (g.batchedUpdates(() => this.advance()), Ye(this)) : Oe.start(this));
+  }
+  // Observe our sources only when we're observed.
+  _attach() {
+    let e = 1;
+    P(I(this.source), (t) => {
+      T(t) && te(t, this), tt(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() {
+    P(I(this.source), (e) => {
+      T(e) && me(e, this);
+    }), this._active.clear(), Ye(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 = I(this.source).reduce(
+      (t, i) => Math.max(t, (tt(i) ? i.priority : 0) + 1),
+      0
+    ));
+  }
+};
+function Ln(e) {
+  return e.idle !== !1;
+}
+function Gt(e) {
+  return !e.size || Array.from(e).every(Ln);
+}
+function Ye(e) {
+  e.idle || (e.idle = !0, P($e(e), (t) => {
+    t.done = !0;
+  }), he(e, {
+    type: "idle",
+    parent: e
+  }));
+}
+O.assign({
+  createStringInterpolator: ui,
+  to: (e, t) => new Mn(e, t)
+});
+var ki = /^--/;
+function Bn(e, t) {
+  return t == null || typeof t == "boolean" || t === "" ? "" : typeof t == "number" && t !== 0 && !ki.test(e) && !(ce.hasOwnProperty(e) && ce[e]) ? t + "px" : ("" + t).trim();
+}
+var Yt = {};
+function Gn(e, t) {
+  if (!e.nodeType || !e.setAttribute)
+    return !1;
+  const i = e.nodeName === "filter" || e.parentNode && e.parentNode.nodeName === "filter", { style: n, children: r, scrollTop: s, scrollLeft: a, viewBox: u, ...d } = t, c = Object.values(d), h = Object.keys(d).map(
+    (l) => i || e.hasAttribute(l) ? l : Yt[l] || (Yt[l] = l.replace(
+      /([A-Z])/g,
+      // Attributes are written in dash case
+      (v) => "-" + v.toLowerCase()
+    ))
+  );
+  r !== void 0 && (e.textContent = r);
+  for (const l in n)
+    if (n.hasOwnProperty(l)) {
+      const v = Bn(l, n[l]);
+      ki.test(l) ? e.style.setProperty(l, v) : e.style[l] = v;
+    }
+  h.forEach((l, v) => {
+    e.setAttribute(l, c[v]);
+  }), s !== void 0 && (e.scrollTop = s), a !== void 0 && (e.scrollLeft = a), u !== void 0 && e.setAttribute("viewBox", u);
+}
+var ce = {
+  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
+}, Yn = (e, t) => e + t.charAt(0).toUpperCase() + t.substring(1), Hn = ["Webkit", "Ms", "Moz", "O"];
+ce = Object.keys(ce).reduce((e, t) => (Hn.forEach((i) => e[Yn(i, t)] = e[t]), e), ce);
+var Wn = /^(matrix|translate|scale|rotate|skew)/, Xn = /^(translate)/, Zn = /^(rotate|skew)/, He = (e, t) => o.num(e) && e !== 0 ? e + t : e, Ie = (e, t) => o.arr(e) ? e.every((i) => Ie(i, t)) : o.num(e) ? e === t : parseFloat(e) === t, Kn = class extends ze {
+  constructor({ x: e, y: t, z: i, ...n }) {
+    const r = [], s = [];
+    (e || t || i) && (r.push([e || 0, t || 0, i || 0]), s.push((a) => [
+      `translate3d(${a.map((u) => He(u, "px")).join(",")})`,
+      // prettier-ignore
+      Ie(a, 0)
+    ])), j(n, (a, u) => {
+      if (u === "transform")
+        r.push([a || ""]), s.push((d) => [d, d === ""]);
+      else if (Wn.test(u)) {
+        if (delete n[u], o.und(a))
+          return;
+        const d = Xn.test(u) ? "px" : Zn.test(u) ? "deg" : "";
+        r.push(I(a)), s.push(
+          u === "rotate3d" ? ([c, h, l, v]) => [
+            `rotate3d(${c},${h},${l},${He(v, d)})`,
+            Ie(v, 0)
+          ] : (c) => [
+            `${u}(${c.map((h) => He(h, d)).join(",")})`,
+            Ie(c, u.startsWith("scale") ? 1 : 0)
+          ]
+        );
+      }
+    }), r.length && (n.transform = new Jn(r, s)), super(n);
+  }
+}, Jn = class extends si {
+  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 P(this.inputs, (i, n) => {
+      const r = k(i[0]), [s, a] = this.transforms[n](
+        o.arr(r) ? r : i.map(k)
+      );
+      e += " " + s, t = t && a;
+    }), t ? "none" : e;
+  }
+  // Start observing our inputs once we have an observer.
+  observerAdded(e) {
+    e == 1 && P(
+      this.inputs,
+      (t) => P(
+        t,
+        (i) => T(i) && te(i, this)
+      )
+    );
+  }
+  // Stop observing our inputs once we have no observers.
+  observerRemoved(e) {
+    e == 0 && P(
+      this.inputs,
+      (t) => P(
+        t,
+        (i) => T(i) && me(i, this)
+      )
+    );
+  }
+  eventObserved(e) {
+    e.type == "change" && (this._value = null), he(this, e);
+  }
+}, er = [
+  "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"
+];
+O.assign({
+  batchedUpdates: Ei,
+  createStringInterpolator: ui,
+  colors: Ni
+});
+bn(er, {
+  applyAnimatedValues: Gn,
+  createAnimatedStyle: (e) => new Kn(e),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getComponentProps: ({ scrollTop: e, scrollLeft: t, ...i }) => i
+});
+var tr = "(prefers-reduced-motion: no-preference)", ir = function() {
+  return typeof window > "u" ? !0 : !window.matchMedia(tr).matches;
+}, nr = function() {
+  var e = le(ir), t = e[0], i = e[1];
+  return B(function() {
+    var n = window.matchMedia("(prefers-reduced-motion: no-preference)"), r = function(s) {
+      i(!s.matches);
     };
-    return n.addEventListener("change", o), function() {
-      return n.removeEventListener("change", o);
+    return n.addEventListener("change", r), function() {
+      return n.removeEventListener("change", r);
     };
-  }, []), e;
-}, V = function(r) {
-  var e = r === void 0 ? {} : r, t = e.x, n = t === void 0 ? 0 : t, o = e.y, a = o === void 0 ? 0 : o, v = e.z, S = v === void 0 ? 0 : v, g = e.rotation, b = g === void 0 ? 0 : g, m = e.rx, C = m === void 0 ? 0 : m, p = e.ry, L = p === void 0 ? 0 : p, l = e.rz, Z = l === void 0 ? b : l, w = e.scale, d = w === void 0 ? 1 : w, _ = e.sx, Q = _ === void 0 ? d || 1 : _, x = e.sy, j = x === void 0 ? d || 1 : x, y = e.sz, q = y === void 0 ? d || 1 : y, k = e.skewX, P = k === void 0 ? 0 : k, h = e.skewY, U = h === void 0 ? 0 : h, T = e.timing, z = T === void 0 ? 150 : T, D = e.springConfig, A = D === void 0 ? {
+  }, []), t;
+}, rr = function(e) {
+  var t = e === void 0 ? {} : e, i = t.x, n = i === void 0 ? 0 : i, r = t.y, s = r === void 0 ? 0 : r, a = t.z, u = a === void 0 ? 0 : a, d = t.rotation, c = d === void 0 ? 0 : d, h = t.rx, l = h === void 0 ? 0 : h, v = t.ry, b = v === void 0 ? 0 : v, y = t.rz, m = y === void 0 ? c : y, _ = t.scale, f = _ === void 0 ? 1 : _, w = t.sx, p = w === void 0 ? f || 1 : w, S = t.sy, x = S === void 0 ? f || 1 : S, q = t.sz, A = q === void 0 ? f || 1 : q, G = t.skewX, R = G === void 0 ? 0 : G, D = t.skewY, F = D === void 0 ? 0 : D, $ = t.timing, X = $ === void 0 ? 150 : $, Se = t.springConfig, Ii = Se === void 0 ? {
     tension: 300,
     friction: 10
-  } : D, M = e.delay, Y = M === void 0 ? 0 : M, i = O(), I = f(!1), s = I[0], X = I[1], B = f(!1), E = B[0], R = B[1], F = J(i ? {} : {
-    transform: s ? "translate3D(" + n + "px, " + a + "px, " + S + `px)
-         rotateX(` + C + "deg) rotateY(" + L + "deg) rotateZ(" + Z + `deg)
-         scale3D(` + Q + "," + j + "," + q + `)
-         skew(` + P + "deg, " + U + "deg)" : `translate3D(0px, 0px, 0px)
+  } : Se, bt = t.delay, wt = bt === void 0 ? 0 : bt, xe = nr(), Pt = le(!1), Ne = Pt[0], St = Pt[1], xt = le(!1), At = xt[0], Rt = xt[1], Ti = Qn(xe ? {} : {
+    transform: Ne ? "translate3D(" + n + "px, " + s + "px, " + u + `px)
+         rotateX(` + l + "deg) rotateY(" + b + "deg) rotateZ(" + m + `deg)
+         scale3D(` + p + "," + x + "," + A + `)
+         skew(` + R + "deg, " + F + "deg)" : `translate3D(0px, 0px, 0px)
          rotateX(0deg) rotateY(0deg) rotateZ(0deg)
          scale3D(1, 1, 1)
          skew(0deg, 0deg)`,
-    config: A,
-    immediate: i
-  }), G = H(function() {
-    i || R(!0);
-  }, [i]);
-  return c(function() {
-    if (E) {
-      var u = window.setTimeout(function() {
-        X(!0), R(!1);
-      }, Y);
+    config: Ii,
+    immediate: xe
+  }), Vi = Ht(function() {
+    xe || Rt(!0);
+  }, [xe]);
+  return B(function() {
+    if (At) {
+      var Qe = window.setTimeout(function() {
+        St(!0), Rt(!1);
+      }, wt);
       return function() {
-        return window.clearTimeout(u);
+        return window.clearTimeout(Qe);
       };
     }
-  }, [E, Y]), c(function() {
-    if (s) {
-      var u = window.setTimeout(function() {
-        return X(!1);
-      }, z);
+  }, [At, wt]), B(function() {
+    if (Ne) {
+      var Qe = window.setTimeout(function() {
+        return St(!1);
+      }, X);
       return function() {
-        return window.clearTimeout(u);
+        return window.clearTimeout(Qe);
       };
     }
-  }, [s, z]), [F, G];
+  }, [Ne, X]), [Ti, Vi];
 };
-const ee = (r) => {
-  const [{ transform: e }, t] = V(r);
+const or = (e) => {
+  const [{ transform: t }, i] = rr(e);
   return [
     {
-      "--transform": e || `translate3D(0px, 0px, 0px)
+      "--transform": t || `translate3D(0px, 0px, 0px)
          rotateX(0deg) rotateY(0deg) rotateZ(0deg)
          scale3D(1, 1, 1)
          skew(0deg, 0deg)`,
       transform: "var(--transform)"
     },
-    t
+    i
   ];
 };
 export {
-  ee as useSafeBoop
+  or as useSafeBoop
 };
 //# sourceMappingURL=useSafeBoop.js.map