@kommo-crm/crm-react-ui-kit 1.1.1-beta.13 → 1.1.1-beta.15

package/dist/useContentPositioning-CLU2E_Oz.mjs

@@ -0,0 +1,2433 @@
+import * as Qt from "react";
+import { forwardRef as st, useEffect as Oe, useLayoutEffect as We, useState as ee, useRef as K, useCallback as Un, useMemo as Pe, useContext as Dn } from "react";
+import { jsx as Re, jsxs as qn } from "react/jsx-runtime";
+import { g as jn } from "./index-DmGLJEdp.mjs";
+import { c as Mt } from "./index-L8X2o7IH.mjs";
+import $n, { unstable_batchedUpdates as zn } from "react-dom";
+import { mergeRefs as Ln } from "./lib/utils.js";
+import { LevelProvider as Qn } from "./components/ContextMenu/providers/LevelProvider/LevelProvider.js";
+import { useContextMenuContext as Mn } from "./components/ContextMenu/ContextMenu.context.js";
+import { ContextMenuMode as _t } from "./components/ContextMenu/ContextMenu.enums.js";
+import "./components/ContextMenu/providers/SubMenuProvider/SubMenuProvider.js";
+import { directionToSide as Gn } from "./components/ContextMenu/components/Content/Content.utils.js";
+import { useStopContextMenuEvents as Bn } from "./components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.js";
+import { Direction as T } from "./components/ContextMenu/components/Content/Content.enums.js";
+import { usePrevious as Hn } from "./components/ContextMenu/hooks/usePrevious/usePrevious.js";
+import './assets/useContentPositioning.css';var bt, Se = $n;
+if (process.env.NODE_ENV === "production")
+  bt = Se.createRoot, Se.hydrateRoot;
+else {
+  var wt = Se.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  bt = function(e, t) {
+    wt.usingClientEntryPoint = !0;
+    try {
+      return Se.createRoot(e, t);
+    } finally {
+      wt.usingClientEntryPoint = !1;
+    }
+  };
+}
+const Wn = "_blocker_1msg5_1", Kn = {
+  blocker: Wn
+}, Gt = st(
+  (e, t) => {
+    const {
+      className: n,
+      onFocus: s,
+      onClick: i,
+      onKeyDown: r,
+      onKeyUp: a,
+      onKeyPress: u,
+      onPointerDown: l,
+      onPointerUp: o,
+      onPointerEnter: m,
+      onPointerLeave: d,
+      onPointerMove: h,
+      ...g
+    } = e, y = Bn({
+      onClick: i,
+      onKeyDown: r,
+      onKeyUp: a,
+      onKeyPress: u,
+      onPointerDown: l,
+      onPointerUp: o,
+      onPointerEnter: m,
+      onPointerLeave: d,
+      onPointerMove: h
+    });
+    return /* @__PURE__ */ Re(
+      "div",
+      {
+        ref: t,
+        className: Mt(Kn.blocker, n),
+        tabIndex: 0,
+        onFocus: (p) => {
+          p.preventDefault(), s == null || s(p);
+        },
+        "data-blocker": !0,
+        ...y,
+        ...g
+      }
+    );
+  }
+);
+Gt.displayName = "FocusBlocker";
+var it = Ae(), w = (e) => we(e, it), rt = Ae();
+w.write = (e) => we(e, rt);
+var Ve = Ae();
+w.onStart = (e) => we(e, Ve);
+var at = Ae();
+w.onFrame = (e) => we(e, at);
+var ot = Ae();
+w.onFinish = (e) => we(e, ot);
+var te = [];
+w.setTimeout = (e, t) => {
+  const n = w.now() + t, s = () => {
+    const r = te.findIndex((a) => a.cancel == s);
+    ~r && te.splice(r, 1), W -= ~r ? 1 : 0;
+  }, i = { time: n, handler: e, cancel: s };
+  return te.splice(Bt(n), 0, i), W += 1, Ht(), i;
+};
+var Bt = (e) => ~(~te.findIndex((t) => t.time > e) || ~te.length);
+w.cancel = (e) => {
+  Ve.delete(e), at.delete(e), ot.delete(e), it.delete(e), rt.delete(e);
+};
+w.sync = (e) => {
+  Ke = !0, w.batchedUpdates(e), Ke = !1;
+};
+w.throttle = (e) => {
+  let t;
+  function n() {
+    try {
+      e(...t);
+    } finally {
+      t = null;
+    }
+  }
+  function s(...i) {
+    t = i, w.onStart(n);
+  }
+  return s.handler = e, s.cancel = () => {
+    Ve.delete(n), t = null;
+  }, s;
+};
+var ut = typeof window < "u" ? window.requestAnimationFrame : (
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  () => {
+  }
+);
+w.use = (e) => ut = e;
+w.now = typeof performance < "u" ? () => performance.now() : Date.now;
+w.batchedUpdates = (e) => e();
+w.catch = console.error;
+w.frameLoop = "always";
+w.advance = () => {
+  w.frameLoop !== "demand" ? console.warn(
+    "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"
+  ) : Kt();
+};
+var H = -1, W = 0, Ke = !1;
+function we(e, t) {
+  Ke ? (t.delete(e), e(0)) : (t.add(e), Ht());
+}
+function Ht() {
+  H < 0 && (H = 0, w.frameLoop !== "demand" && ut(Wt));
+}
+function Yn() {
+  H = -1;
+}
+function Wt() {
+  ~H && (ut(Wt), w.batchedUpdates(Kt));
+}
+function Kt() {
+  const e = H;
+  H = w.now();
+  const t = Bt(H);
+  if (t && (Yt(te.splice(0, t), (n) => n.handler()), W -= t), !W) {
+    Yn();
+    return;
+  }
+  Ve.flush(), it.flush(e ? Math.min(64, H - e) : 16.667), at.flush(), rt.flush(), ot.flush();
+}
+function Ae() {
+  let e = /* @__PURE__ */ new Set(), t = e;
+  return {
+    add(n) {
+      W += t == e && !e.has(n) ? 1 : 0, e.add(n);
+    },
+    delete(n) {
+      return W -= t == e && e.has(n) ? 1 : 0, e.delete(n);
+    },
+    flush(n) {
+      t.size && (e = /* @__PURE__ */ new Set(), W -= t.size, Yt(t, (s) => s(n) && e.add(s)), W += e.size, t = e);
+    }
+  };
+}
+function Yt(e, t) {
+  e.forEach((n) => {
+    try {
+      t(n);
+    } catch (s) {
+      w.catch(s);
+    }
+  });
+}
+var Zn = Object.defineProperty, Xn = (e, t) => {
+  for (var n in t)
+    Zn(e, n, { get: t[n], enumerable: !0 });
+}, j = {};
+Xn(j, {
+  assign: () => es,
+  colors: () => Y,
+  createStringInterpolator: () => lt,
+  skipAnimation: () => Xt,
+  to: () => Zt,
+  willAdvance: () => dt
+});
+function Ye() {
+}
+var Jn = (e, t, n) => Object.defineProperty(e, t, { value: n, 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 G(e, t) {
+  if (c.arr(e)) {
+    if (!c.arr(t) || e.length !== t.length) return !1;
+    for (let n = 0; n < e.length; n++)
+      if (e[n] !== t[n]) return !1;
+    return !0;
+  }
+  return e === t;
+}
+var P = (e, t) => e.forEach(t);
+function Q(e, t, n) {
+  if (c.arr(e)) {
+    for (let s = 0; s < e.length; s++)
+      t.call(n, e[s], `${s}`);
+    return;
+  }
+  for (const s in e)
+    e.hasOwnProperty(s) && t.call(n, e[s], s);
+}
+var O = (e) => c.und(e) ? [] : c.arr(e) ? e : [e];
+function ce(e, t) {
+  if (e.size) {
+    const n = Array.from(e);
+    e.clear(), P(n, t);
+  }
+}
+var ue = (e, ...t) => ce(e, (n) => n(...t)), ct = () => typeof window > "u" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent), lt, Zt, Y = null, Xt = !1, dt = Ye, es = (e) => {
+  e.to && (Zt = e.to), e.now && (w.now = e.now), e.colors !== void 0 && (Y = e.colors), e.skipAnimation != null && (Xt = e.skipAnimation), e.createStringInterpolator && (lt = e.createStringInterpolator), e.requestAnimationFrame && w.use(e.requestAnimationFrame), e.batchedUpdates && (w.batchedUpdates = e.batchedUpdates), e.willAdvance && (dt = e.willAdvance), e.frameLoop && (w.frameLoop = e.frameLoop);
+}, le = /* @__PURE__ */ new Set(), N = [], Le = [], ke = 0, Ne = {
+  get idle() {
+    return !le.size && !N.length;
+  },
+  /** Advance the given animation on every frame until idle. */
+  start(e) {
+    ke > e.priority ? (le.add(e), w.onStart(ts)) : (Jt(e), w(Ze));
+  },
+  /** Advance all animations by the given time. */
+  advance: Ze,
+  /** Call this when an animation's priority changes. */
+  sort(e) {
+    if (ke)
+      w.onFrame(() => Ne.sort(e));
+    else {
+      const t = N.indexOf(e);
+      ~t && (N.splice(t, 1), en(e));
+    }
+  },
+  /**
+   * Clear all animations. For testing purposes.
+   *
+   * ☠️ Never call this from within the frameloop.
+   */
+  clear() {
+    N = [], le.clear();
+  }
+};
+function ts() {
+  le.forEach(Jt), le.clear(), w(Ze);
+}
+function Jt(e) {
+  N.includes(e) || en(e);
+}
+function en(e) {
+  N.splice(
+    ns(N, (t) => t.priority > e.priority),
+    0,
+    e
+  );
+}
+function Ze(e) {
+  const t = Le;
+  for (let n = 0; n < N.length; n++) {
+    const s = N[n];
+    ke = s.priority, s.idle || (dt(s), s.advance(e), s.idle || t.push(s));
+  }
+  return ke = 0, Le = N, Le.length = 0, N = t, N.length > 0;
+}
+function ns(e, t) {
+  const n = e.findIndex(t);
+  return n < 0 ? e.length : n;
+}
+var ss = {
+  transparent: 0,
+  aliceblue: 4042850303,
+  antiquewhite: 4209760255,
+  aqua: 16777215,
+  aquamarine: 2147472639,
+  azure: 4043309055,
+  beige: 4126530815,
+  bisque: 4293182719,
+  black: 255,
+  blanchedalmond: 4293643775,
+  blue: 65535,
+  blueviolet: 2318131967,
+  brown: 2771004159,
+  burlywood: 3736635391,
+  burntsienna: 3934150143,
+  cadetblue: 1604231423,
+  chartreuse: 2147418367,
+  chocolate: 3530104575,
+  coral: 4286533887,
+  cornflowerblue: 1687547391,
+  cornsilk: 4294499583,
+  crimson: 3692313855,
+  cyan: 16777215,
+  darkblue: 35839,
+  darkcyan: 9145343,
+  darkgoldenrod: 3095792639,
+  darkgray: 2846468607,
+  darkgreen: 6553855,
+  darkgrey: 2846468607,
+  darkkhaki: 3182914559,
+  darkmagenta: 2332068863,
+  darkolivegreen: 1433087999,
+  darkorange: 4287365375,
+  darkorchid: 2570243327,
+  darkred: 2332033279,
+  darksalmon: 3918953215,
+  darkseagreen: 2411499519,
+  darkslateblue: 1211993087,
+  darkslategray: 793726975,
+  darkslategrey: 793726975,
+  darkturquoise: 13554175,
+  darkviolet: 2483082239,
+  deeppink: 4279538687,
+  deepskyblue: 12582911,
+  dimgray: 1768516095,
+  dimgrey: 1768516095,
+  dodgerblue: 512819199,
+  firebrick: 2988581631,
+  floralwhite: 4294635775,
+  forestgreen: 579543807,
+  fuchsia: 4278255615,
+  gainsboro: 3705462015,
+  ghostwhite: 4177068031,
+  gold: 4292280575,
+  goldenrod: 3668254975,
+  gray: 2155905279,
+  green: 8388863,
+  greenyellow: 2919182335,
+  grey: 2155905279,
+  honeydew: 4043305215,
+  hotpink: 4285117695,
+  indianred: 3445382399,
+  indigo: 1258324735,
+  ivory: 4294963455,
+  khaki: 4041641215,
+  lavender: 3873897215,
+  lavenderblush: 4293981695,
+  lawngreen: 2096890111,
+  lemonchiffon: 4294626815,
+  lightblue: 2916673279,
+  lightcoral: 4034953471,
+  lightcyan: 3774873599,
+  lightgoldenrodyellow: 4210742015,
+  lightgray: 3553874943,
+  lightgreen: 2431553791,
+  lightgrey: 3553874943,
+  lightpink: 4290167295,
+  lightsalmon: 4288707327,
+  lightseagreen: 548580095,
+  lightskyblue: 2278488831,
+  lightslategray: 2005441023,
+  lightslategrey: 2005441023,
+  lightsteelblue: 2965692159,
+  lightyellow: 4294959359,
+  lime: 16711935,
+  limegreen: 852308735,
+  linen: 4210091775,
+  magenta: 4278255615,
+  maroon: 2147483903,
+  mediumaquamarine: 1724754687,
+  mediumblue: 52735,
+  mediumorchid: 3126187007,
+  mediumpurple: 2473647103,
+  mediumseagreen: 1018393087,
+  mediumslateblue: 2070474495,
+  mediumspringgreen: 16423679,
+  mediumturquoise: 1221709055,
+  mediumvioletred: 3340076543,
+  midnightblue: 421097727,
+  mintcream: 4127193855,
+  mistyrose: 4293190143,
+  moccasin: 4293178879,
+  navajowhite: 4292783615,
+  navy: 33023,
+  oldlace: 4260751103,
+  olive: 2155872511,
+  olivedrab: 1804477439,
+  orange: 4289003775,
+  orangered: 4282712319,
+  orchid: 3664828159,
+  palegoldenrod: 4008225535,
+  palegreen: 2566625535,
+  paleturquoise: 2951671551,
+  palevioletred: 3681588223,
+  papayawhip: 4293907967,
+  peachpuff: 4292524543,
+  peru: 3448061951,
+  pink: 4290825215,
+  plum: 3718307327,
+  powderblue: 2967529215,
+  purple: 2147516671,
+  rebeccapurple: 1714657791,
+  red: 4278190335,
+  rosybrown: 3163525119,
+  royalblue: 1097458175,
+  saddlebrown: 2336560127,
+  salmon: 4202722047,
+  sandybrown: 4104413439,
+  seagreen: 780883967,
+  seashell: 4294307583,
+  sienna: 2689740287,
+  silver: 3233857791,
+  skyblue: 2278484991,
+  slateblue: 1784335871,
+  slategray: 1887473919,
+  slategrey: 1887473919,
+  snow: 4294638335,
+  springgreen: 16744447,
+  steelblue: 1182971135,
+  tan: 3535047935,
+  teal: 8421631,
+  thistle: 3636451583,
+  tomato: 4284696575,
+  turquoise: 1088475391,
+  violet: 4001558271,
+  wheat: 4125012991,
+  white: 4294967295,
+  whitesmoke: 4126537215,
+  yellow: 4294902015,
+  yellowgreen: 2597139199
+}, q = "[-+]?\\d*\\.?\\d+", Fe = q + "%";
+function Ue(...e) {
+  return "\\(\\s*(" + e.join(")\\s*,\\s*(") + ")\\s*\\)";
+}
+var is = new RegExp("rgb" + Ue(q, q, q)), rs = new RegExp("rgba" + Ue(q, q, q, q)), as = new RegExp("hsl" + Ue(q, Fe, Fe)), os = new RegExp(
+  "hsla" + Ue(q, Fe, Fe, q)
+), us = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, cs = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, ls = /^#([0-9a-fA-F]{6})$/, ds = /^#([0-9a-fA-F]{8})$/;
+function fs(e) {
+  let t;
+  return typeof e == "number" ? e >>> 0 === e && e >= 0 && e <= 4294967295 ? e : null : (t = ls.exec(e)) ? parseInt(t[1] + "ff", 16) >>> 0 : Y && Y[e] !== void 0 ? Y[e] : (t = is.exec(e)) ? (J(t[1]) << 24 | // r
+  J(t[2]) << 16 | // g
+  J(t[3]) << 8 | // b
+  255) >>> // a
+  0 : (t = rs.exec(e)) ? (J(t[1]) << 24 | // r
+  J(t[2]) << 16 | // g
+  J(t[3]) << 8 | // b
+  St(t[4])) >>> // a
+  0 : (t = us.exec(e)) ? parseInt(
+    t[1] + t[1] + // r
+    t[2] + t[2] + // g
+    t[3] + t[3] + // b
+    "ff",
+    // a
+    16
+  ) >>> 0 : (t = ds.exec(e)) ? parseInt(t[1], 16) >>> 0 : (t = cs.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 = as.exec(e)) ? (At(
+    Pt(t[1]),
+    // h
+    Ie(t[2]),
+    // s
+    Ie(t[3])
+    // l
+  ) | 255) >>> // a
+  0 : (t = os.exec(e)) ? (At(
+    Pt(t[1]),
+    // h
+    Ie(t[2]),
+    // s
+    Ie(t[3])
+    // l
+  ) | St(t[4])) >>> // a
+  0 : null;
+}
+function Qe(e, t, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? e + (t - e) * 6 * n : n < 1 / 2 ? t : n < 2 / 3 ? e + (t - e) * (2 / 3 - n) * 6 : e;
+}
+function At(e, t, n) {
+  const s = n < 0.5 ? n * (1 + t) : n + t - n * t, i = 2 * n - s, r = Qe(i, s, e + 1 / 3), a = Qe(i, s, e), u = Qe(i, s, e - 1 / 3);
+  return Math.round(r * 255) << 24 | Math.round(a * 255) << 16 | Math.round(u * 255) << 8;
+}
+function J(e) {
+  const t = parseInt(e, 10);
+  return t < 0 ? 0 : t > 255 ? 255 : t;
+}
+function Pt(e) {
+  return (parseFloat(e) % 360 + 360) % 360 / 360;
+}
+function St(e) {
+  const t = parseFloat(e);
+  return t < 0 ? 0 : t > 1 ? 255 : Math.round(t * 255);
+}
+function Ie(e) {
+  const t = parseFloat(e);
+  return t < 0 ? 0 : t > 100 ? 1 : t / 100;
+}
+function It(e) {
+  let t = fs(e);
+  if (t === null) return e;
+  t = t || 0;
+  const n = (t & 4278190080) >>> 24, s = (t & 16711680) >>> 16, i = (t & 65280) >>> 8, r = (t & 255) / 255;
+  return `rgba(${n}, ${s}, ${i}, ${r})`;
+}
+var he = (e, t, n) => {
+  if (c.fun(e))
+    return e;
+  if (c.arr(e))
+    return he({
+      range: e,
+      output: t,
+      extrapolate: n
+    });
+  if (c.str(e.output[0]))
+    return lt(e);
+  const s = e, i = s.output, r = s.range || [0, 1], a = s.extrapolateLeft || s.extrapolate || "extend", u = s.extrapolateRight || s.extrapolate || "extend", l = s.easing || ((o) => o);
+  return (o) => {
+    const m = ms(o, r);
+    return hs(
+      o,
+      r[m],
+      r[m + 1],
+      i[m],
+      i[m + 1],
+      l,
+      a,
+      u,
+      s.map
+    );
+  };
+};
+function hs(e, t, n, s, i, r, a, u, l) {
+  let o = l ? l(e) : e;
+  if (o < t) {
+    if (a === "identity") return o;
+    a === "clamp" && (o = t);
+  }
+  if (o > n) {
+    if (u === "identity") return o;
+    u === "clamp" && (o = n);
+  }
+  return s === i ? s : t === n ? e <= t ? s : i : (t === -1 / 0 ? o = -o : n === 1 / 0 ? o = o - t : o = (o - t) / (n - t), o = r(o), s === -1 / 0 ? o = -o : i === 1 / 0 ? o = o + s : o = o * (i - s) + s, o);
+}
+function ms(e, t) {
+  for (var n = 1; n < t.length - 1 && !(t[n] >= e); ++n)
+    ;
+  return n - 1;
+}
+var tn = {
+  linear: (e) => e,
+  easeInOutCubic: (e) => e < 0.5 ? 4 * e * e * e : 1 - Math.pow(-2 * e + 2, 3) / 2
+}, me = Symbol.for("FluidValue.get"), se = Symbol.for("FluidValue.observers"), V = (e) => !!(e && e[me]), E = (e) => e && e[me] ? e[me]() : e, Rt = (e) => e[se] || null;
+function ps(e, t) {
+  e.eventObserved ? e.eventObserved(t) : e(t);
+}
+function pe(e, t) {
+  const n = e[se];
+  n && n.forEach((s) => {
+    ps(s, t);
+  });
+}
+var nn = class {
+  constructor(e) {
+    if (!e && !(e = this.get))
+      throw Error("Unknown getter");
+    gs(this, e);
+  }
+}, gs = (e, t) => sn(e, me, t);
+function ie(e, t) {
+  if (e[me]) {
+    let n = e[se];
+    n || sn(e, se, n = /* @__PURE__ */ new Set()), n.has(t) || (n.add(t), e.observerAdded && e.observerAdded(n.size, t));
+  }
+  return t;
+}
+function ge(e, t) {
+  const n = e[se];
+  if (n && n.has(t)) {
+    const s = n.size - 1;
+    s ? n.delete(t) : e[se] = null, e.observerRemoved && e.observerRemoved(s, t);
+  }
+}
+var sn = (e, t, n) => Object.defineProperty(e, t, {
+  value: n,
+  writable: !0,
+  configurable: !0
+}), xe = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, vs = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi, xt = new RegExp(`(${xe.source})(%|[a-z]+)`, "i"), ys = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, De = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/, rn = (e) => {
+  const [t, n] = _s(e);
+  if (!t || ct())
+    return e;
+  const s = window.getComputedStyle(document.documentElement).getPropertyValue(t);
+  if (s)
+    return s.trim();
+  if (n && n.startsWith("--")) {
+    const i = window.getComputedStyle(document.documentElement).getPropertyValue(n);
+    return i || e;
+  } else {
+    if (n && De.test(n))
+      return rn(n);
+    if (n)
+      return n;
+  }
+  return e;
+}, _s = (e) => {
+  const t = De.exec(e);
+  if (!t) return [,];
+  const [, n, s] = t;
+  return [n, s];
+}, Me, bs = (e, t, n, s, i) => `rgba(${Math.round(t)}, ${Math.round(n)}, ${Math.round(s)}, ${i})`, an = (e) => {
+  Me || (Me = Y ? (
+    // match color names, ignore partial matches
+    new RegExp(`(${Object.keys(Y).join("|")})(?!\\w)`, "g")
+  ) : (
+    // never match
+    /^\b$/
+  ));
+  const t = e.output.map((r) => E(r).replace(De, rn).replace(vs, It).replace(Me, It)), n = t.map((r) => r.match(xe).map(Number)), i = n[0].map(
+    (r, a) => n.map((u) => {
+      if (!(a in u))
+        throw Error('The arity of each "output" value must be equal');
+      return u[a];
+    })
+  ).map(
+    (r) => he({ ...e, output: r })
+  );
+  return (r) => {
+    var l;
+    const a = !xt.test(t[0]) && ((l = t.find((o) => xt.test(o))) == null ? void 0 : l.replace(xe, ""));
+    let u = 0;
+    return t[0].replace(
+      xe,
+      () => `${i[u++](r)}${a || ""}`
+    ).replace(ys, bs);
+  };
+}, ft = "react-spring: ", on = (e) => {
+  const t = e;
+  let n = !1;
+  if (typeof t != "function")
+    throw new TypeError(`${ft}once requires a function parameter`);
+  return (...s) => {
+    n || (t(...s), n = !0);
+  };
+}, ws = on(console.warn);
+function As() {
+  ws(
+    `${ft}The "interpolate" function is deprecated in v9 (use "to" instead)`
+  );
+}
+var Ps = on(console.warn);
+function Ss() {
+  Ps(
+    `${ft}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 qe(e) {
+  return c.str(e) && (e[0] == "#" || /\d/.test(e) || // Do not identify a CSS variable as an AnimatedString if its SSR
+  !ct() && De.test(e) || e in (Y || {}));
+}
+var ht = ct() ? Oe : We, Is = () => {
+  const e = K(!1);
+  return ht(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), e;
+};
+function un() {
+  const e = ee()[1], t = Is();
+  return () => {
+    t.current && e(Math.random());
+  };
+}
+var cn = (e) => Oe(e, Rs), Rs = [];
+function Ct(e) {
+  const t = K(void 0);
+  return Oe(() => {
+    t.current = e;
+  }), t.current;
+}
+var ve = Symbol.for("Animated:node"), xs = (e) => !!e && e[ve] === e, L = (e) => e && e[ve], mt = (e, t) => Jn(e, ve, t), je = (e) => e && e[ve] && e[ve].getPayload(), ln = class {
+  constructor() {
+    mt(this, this);
+  }
+  /** Get every `AnimatedValue` used by this node. */
+  getPayload() {
+    return this.payload || [];
+  }
+}, $e = class dn extends ln {
+  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 dn(t);
+  }
+  getPayload() {
+    return [this];
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(t, n) {
+    return c.num(t) && (this.lastPosition = t, n && (t = Math.round(t / n) * n, 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);
+  }
+}, Te = class fn extends $e {
+  constructor(t) {
+    super(0), this._string = null, this._toString = he({
+      output: [t, t]
+    });
+  }
+  /** @internal */
+  static create(t) {
+    return new fn(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 = he({
+      output: [this.getValue(), t]
+    })), this._value = 0, super.reset();
+  }
+}, Ee = { dependencies: null }, ze = class extends ln {
+  constructor(e) {
+    super(), this.source = e, this.setValue(e);
+  }
+  getValue(e) {
+    const t = {};
+    return Q(this.source, (n, s) => {
+      xs(n) ? t[s] = n.getValue(e) : V(n) ? t[s] = E(n) : e || (t[s] = n);
+    }), 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 Q(e, this._addToPayload, t), Array.from(t);
+    }
+  }
+  /** Add to a payload set. */
+  _addToPayload(e) {
+    Ee.dependencies && V(e) && Ee.dependencies.add(e);
+    const t = je(e);
+    t && P(t, (n) => this.add(n));
+  }
+}, Cs = class hn extends ze {
+  constructor(t) {
+    super(t);
+  }
+  /** @internal */
+  static create(t) {
+    return new hn(t);
+  }
+  getValue() {
+    return this.source.map((t) => t.getValue());
+  }
+  setValue(t) {
+    const n = this.getPayload();
+    return t.length == n.length ? n.map((s, i) => s.setValue(t[i])).some(Boolean) : (super.setValue(t.map(ks)), !0);
+  }
+};
+function ks(e) {
+  return (qe(e) ? Te : $e).create(e);
+}
+function Xe(e) {
+  const t = L(e);
+  return t ? t.constructor : c.arr(e) ? Cs : qe(e) ? Te : $e;
+}
+var kt = (e, t) => {
+  const n = (
+    // Function components must use "forwardRef" to avoid being
+    // re-rendered on every animation frame.
+    !c.fun(e) || e.prototype && e.prototype.isReactComponent
+  );
+  return st((s, i) => {
+    const r = K(null), a = n && // eslint-disable-next-line react-hooks/rules-of-hooks
+    Un(
+      (_) => {
+        r.current = Es(i, _);
+      },
+      [i]
+    ), [u, l] = Ts(s, t), o = un(), m = () => {
+      const _ = r.current;
+      if (n && !_)
+        return;
+      (_ ? t.applyAnimatedValues(_, u.getValue(!0)) : !1) === !1 && o();
+    }, d = new Fs(m, l), h = K(void 0);
+    ht(() => (h.current = d, P(l, (_) => ie(_, d)), () => {
+      h.current && (P(
+        h.current.deps,
+        (_) => ge(_, h.current)
+      ), w.cancel(h.current.update));
+    })), Oe(m, []), cn(() => () => {
+      const _ = h.current;
+      P(_.deps, (y) => ge(y, _));
+    });
+    const g = t.getComponentProps(u.getValue());
+    return /* @__PURE__ */ Qt.createElement(e, { ...g, ref: a });
+  });
+}, Fs = class {
+  constructor(e, t) {
+    this.update = e, this.deps = t;
+  }
+  eventObserved(e) {
+    e.type == "change" && w.write(this.update);
+  }
+};
+function Ts(e, t) {
+  const n = /* @__PURE__ */ new Set();
+  return Ee.dependencies = n, e.style && (e = {
+    ...e,
+    style: t.createAnimatedStyle(e.style)
+  }), e = new ze(e), Ee.dependencies = null, [e, n];
+}
+function Es(e, t) {
+  return e && (c.fun(e) ? e(t) : e.current = t), t;
+}
+var Ft = Symbol.for("AnimatedComponent"), Os = (e, {
+  applyAnimatedValues: t = () => !1,
+  createAnimatedStyle: n = (i) => new ze(i),
+  getComponentProps: s = (i) => i
+} = {}) => {
+  const i = {
+    applyAnimatedValues: t,
+    createAnimatedStyle: n,
+    getComponentProps: s
+  }, r = (a) => {
+    const u = Tt(a) || "Anonymous";
+    return c.str(a) ? a = r[a] || (r[a] = kt(a, i)) : a = a[Ft] || (a[Ft] = kt(a, i)), a.displayName = `Animated(${u})`, a;
+  };
+  return Q(e, (a, u) => {
+    c.arr(e) && (u = Tt(a)), r[u] = r(a);
+  }), {
+    animated: r
+  };
+}, Tt = (e) => c.str(e) ? e : e && c.str(e.displayName) ? e.displayName : c.fun(e) && e.name || null;
+function Z(e, ...t) {
+  return c.fun(e) ? e(...t) : e;
+}
+var de = (e, t) => e === !0 || !!(t && e && (c.fun(e) ? e(t) : O(e).includes(t))), mn = (e, t) => c.obj(e) ? t && e[t] : e, pn = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, Vs = (e) => e, pt = (e, t = Vs) => {
+  let n = Ns;
+  e.default && e.default !== !0 && (e = e.default, n = Object.keys(e));
+  const s = {};
+  for (const i of n) {
+    const r = t(e[i], i);
+    c.und(r) || (s[i] = r);
+  }
+  return s;
+}, Ns = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+], Us = {
+  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 Ds(e) {
+  const t = {};
+  let n = 0;
+  if (Q(e, (s, i) => {
+    Us[i] || (t[i] = s, n++);
+  }), n)
+    return t;
+}
+function gn(e) {
+  const t = Ds(e);
+  if (t) {
+    const n = { to: t };
+    return Q(e, (s, i) => i in t || (n[i] = s)), n;
+  }
+  return { ...e };
+}
+function ye(e) {
+  return e = E(e), c.arr(e) ? e.map(ye) : qe(e) ? j.createStringInterpolator({
+    range: [0, 1],
+    output: [e, e]
+  })(1) : e;
+}
+function qs(e) {
+  for (const t in e) return !0;
+  return !1;
+}
+function Je(e) {
+  return c.fun(e) || c.arr(e) && c.obj(e[0]);
+}
+function js(e, t) {
+  var n;
+  (n = e.ref) == null || n.delete(e), t == null || t.delete(e);
+}
+function $s(e, t) {
+  var n;
+  t && e.ref !== t && ((n = e.ref) == null || n.delete(e), t.add(e), e.ref = t);
+}
+var zs = {
+  default: { tension: 170, friction: 26 }
+}, et = {
+  ...zs.default,
+  mass: 1,
+  damping: 1,
+  easing: tn.linear,
+  clamp: !1
+}, Ls = class {
+  constructor() {
+    this.velocity = 0, Object.assign(this, et);
+  }
+};
+function Qs(e, t, n) {
+  n && (n = { ...n }, Et(n, t), t = { ...n, ...t }), Et(e, t), Object.assign(e, t);
+  for (const a in et)
+    e[a] == null && (e[a] = et[a]);
+  let { frequency: s, damping: i } = e;
+  const { mass: r } = e;
+  return c.und(s) || (s < 0.01 && (s = 0.01), i < 0 && (i = 0), e.tension = Math.pow(2 * Math.PI / s, 2) * r, e.friction = 4 * Math.PI * i * r / s), e;
+}
+function Et(e, t) {
+  if (!c.und(t.decay))
+    e.duration = void 0;
+  else {
+    const n = !c.und(t.tension) || !c.und(t.friction);
+    (n || !c.und(t.frequency) || !c.und(t.damping) || !c.und(t.mass)) && (e.duration = void 0, e.decay = void 0), n && (e.frequency = void 0);
+  }
+}
+var Ot = [], Ms = class {
+  constructor() {
+    this.changed = !1, this.values = Ot, this.toValues = null, this.fromValues = Ot, this.config = new Ls(), this.immediate = !1;
+  }
+};
+function vn(e, { key: t, props: n, defaultProps: s, state: i, actions: r }) {
+  return new Promise((a, u) => {
+    let l, o, m = de(n.cancel ?? (s == null ? void 0 : s.cancel), t);
+    if (m)
+      g();
+    else {
+      c.und(n.pause) || (i.paused = de(n.pause, t));
+      let _ = s == null ? void 0 : s.pause;
+      _ !== !0 && (_ = i.paused || de(_, t)), l = Z(n.delay || 0, t), _ ? (i.resumeQueue.add(h), r.pause()) : (r.resume(), h());
+    }
+    function d() {
+      i.resumeQueue.add(h), i.timeouts.delete(o), o.cancel(), l = o.time - w.now();
+    }
+    function h() {
+      l > 0 && !j.skipAnimation ? (i.delayed = !0, o = w.setTimeout(g, l), i.pauseQueue.add(d), i.timeouts.add(o)) : g();
+    }
+    function g() {
+      i.delayed && (i.delayed = !1), i.pauseQueue.delete(d), i.timeouts.delete(o), e <= (i.cancelId || 0) && (m = !0);
+      try {
+        r.start({ ...n, callId: e, cancel: m }, a);
+      } catch (_) {
+        u(_);
+      }
+    }
+  });
+}
+var gt = (e, t) => t.length == 1 ? t[0] : t.some((n) => n.cancelled) ? ne(e.get()) : t.every((n) => n.noop) ? yn(e.get()) : D(
+  e.get(),
+  t.every((n) => n.finished)
+), yn = (e) => ({
+  value: e,
+  noop: !0,
+  finished: !0,
+  cancelled: !1
+}), D = (e, t, n = !1) => ({
+  value: e,
+  finished: t,
+  cancelled: n
+}), ne = (e) => ({
+  value: e,
+  cancelled: !0,
+  finished: !1
+});
+function _n(e, t, n, s) {
+  const { callId: i, parentId: r, onRest: a } = t, { asyncTo: u, promise: l } = n;
+  return !r && e === u && !t.reset ? l : n.promise = (async () => {
+    n.asyncId = i, n.asyncTo = e;
+    const o = pt(
+      t,
+      (p, f) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        f === "onRest" ? void 0 : p
+      )
+    );
+    let m, d;
+    const h = new Promise(
+      (p, f) => (m = p, d = f)
+    ), g = (p) => {
+      const f = (
+        // The `cancel` prop or `stop` method was used.
+        i <= (n.cancelId || 0) && ne(s) || // The async `to` prop was replaced.
+        i !== n.asyncId && D(s, !1)
+      );
+      if (f)
+        throw p.result = f, d(p), p;
+    }, _ = (p, f) => {
+      const b = new Vt(), v = new Nt();
+      return (async () => {
+        if (j.skipAnimation)
+          throw _e(n), v.result = D(s, !1), d(v), v;
+        g(b);
+        const A = c.obj(p) ? { ...p } : { ...f, to: p };
+        A.parentId = i, Q(o, (k, x) => {
+          c.und(A[x]) && (A[x] = k);
+        });
+        const S = await s.start(A);
+        return g(b), n.paused && await new Promise((k) => {
+          n.resumeQueue.add(k);
+        }), S;
+      })();
+    };
+    let y;
+    if (j.skipAnimation)
+      return _e(n), D(s, !1);
+    try {
+      let p;
+      c.arr(e) ? p = (async (f) => {
+        for (const b of f)
+          await _(b);
+      })(e) : p = Promise.resolve(e(_, s.stop.bind(s))), await Promise.all([p.then(m), h]), y = D(s.get(), !0, !1);
+    } catch (p) {
+      if (p instanceof Vt)
+        y = p.result;
+      else if (p instanceof Nt)
+        y = p.result;
+      else
+        throw p;
+    } finally {
+      i == n.asyncId && (n.asyncId = r, n.asyncTo = r ? u : void 0, n.promise = r ? l : void 0);
+    }
+    return c.fun(a) && w.batchedUpdates(() => {
+      a(y, s, s.item);
+    }), y;
+  })();
+}
+function _e(e, t) {
+  ce(e.timeouts, (n) => n.cancel()), e.pauseQueue.clear(), e.resumeQueue.clear(), e.asyncId = e.asyncTo = e.promise = void 0, t && (e.cancelId = t);
+}
+var Vt = 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."
+    );
+  }
+}, Nt = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+}, tt = (e) => e instanceof vt, Gs = 1, vt = class extends nn {
+  constructor() {
+    super(...arguments), this.id = Gs++, 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 = L(this);
+    return e && e.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...e) {
+    return j.to(this, e);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...e) {
+    return As(), j.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) {
+    pe(this, {
+      type: "change",
+      parent: this,
+      value: e,
+      idle: t
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(e) {
+    this.idle || Ne.sort(this), pe(this, {
+      type: "priority",
+      parent: this,
+      priority: e
+    });
+  }
+}, X = Symbol.for("SpringPhase"), bn = 1, wn = 2, An = 4, Ge = (e) => (e[X] & bn) > 0, B = (e) => (e[X] & wn) > 0, re = (e) => (e[X] & An) > 0, Ut = (e, t) => t ? e[X] |= wn | bn : e[X] &= -3, Dt = (e, t) => t ? e[X] |= An : e[X] &= -5, Bs = class extends vt {
+  constructor(e, t) {
+    if (super(), this.animation = new Ms(), 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 n = c.obj(e) ? { ...e } : { ...t, from: e };
+      c.und(n.default) && (n.default = !0), this.start(n);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(B(this) || this._state.asyncTo) || re(this);
+  }
+  get goal() {
+    return E(this.animation.to);
+  }
+  get velocity() {
+    const e = L(this);
+    return e instanceof $e ? 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 B(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return re(this);
+  }
+  /**
+   *
+   *
+   */
+  get isDelayed() {
+    return this._state.delayed;
+  }
+  /** Advance the current animation by a number of milliseconds */
+  advance(e) {
+    let t = !0, n = !1;
+    const s = this.animation;
+    let { toValues: i } = s;
+    const { config: r } = s, a = je(s.to);
+    !a && V(s.to) && (i = O(E(s.to))), s.values.forEach((o, m) => {
+      if (o.done) return;
+      const d = (
+        // Animated strings always go from 0 to 1.
+        o.constructor == Te ? 1 : a ? a[m].lastPosition : i[m]
+      );
+      let h = s.immediate, g = d;
+      if (!h) {
+        if (g = o.lastPosition, r.tension <= 0) {
+          o.done = !0;
+          return;
+        }
+        let _ = o.elapsedTime += e;
+        const y = s.fromValues[m], p = o.v0 != null ? o.v0 : o.v0 = c.arr(r.velocity) ? r.velocity[m] : r.velocity;
+        let f;
+        const b = r.precision || (y == d ? 5e-3 : Math.min(1, Math.abs(d - y) * 1e-3));
+        if (c.und(r.duration))
+          if (r.decay) {
+            const v = r.decay === !0 ? 0.998 : r.decay, A = Math.exp(-(1 - v) * _);
+            g = y + p / (1 - v) * (1 - A), h = Math.abs(o.lastPosition - g) <= b, f = p * A;
+          } else {
+            f = o.lastVelocity == null ? p : o.lastVelocity;
+            const v = r.restVelocity || b / 10, A = r.clamp ? 0 : r.bounce, S = !c.und(A), k = y == d ? o.v0 > 0 : y < d;
+            let x, F = !1;
+            const I = 1, R = Math.ceil(e / I);
+            for (let C = 0; C < R && (x = Math.abs(f) > v, !(!x && (h = Math.abs(d - g) <= b, h))); ++C) {
+              S && (F = g == d || g > d == k, F && (f = -f * A, g = d));
+              const $ = -r.tension * 1e-6 * (g - d), z = -r.friction * 1e-3 * f, M = ($ + z) / r.mass;
+              f = f + M * I, g = g + f * I;
+            }
+          }
+        else {
+          let v = 1;
+          r.duration > 0 && (this._memoizedDuration !== r.duration && (this._memoizedDuration = r.duration, o.durationProgress > 0 && (o.elapsedTime = r.duration * o.durationProgress, _ = o.elapsedTime += e)), v = (r.progress || 0) + _ / this._memoizedDuration, v = v > 1 ? 1 : v < 0 ? 0 : v, o.durationProgress = v), g = y + r.easing(v) * (d - y), f = (g - o.lastPosition) / e, h = v == 1;
+        }
+        o.lastVelocity = f, Number.isNaN(g) && (console.warn("Got NaN while animating:", this), h = !0);
+      }
+      a && !a[m].done && (h = !1), h ? o.done = !0 : t = !1, o.setValue(g, r.round) && (n = !0);
+    });
+    const u = L(this), l = u.getValue();
+    if (t) {
+      const o = E(s.to);
+      (l !== o || n) && !r.decay ? (u.setValue(o), this._onChange(o)) : n && r.decay && this._onChange(l), this._stop();
+    } else n && this._onChange(l);
+  }
+  /** Set the current value, while stopping the current animation */
+  set(e) {
+    return w.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 (B(this)) {
+      const { to: e, config: t } = this.animation;
+      w.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 n;
+    return c.und(e) ? (n = this.queue || [], this.queue = []) : n = [c.obj(e) ? e : { ...t, to: e }], Promise.all(
+      n.map((s) => this._update(s))
+    ).then((s) => gt(this, s));
+  }
+  /**
+   * 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()), _e(this._state, e && this._lastCallId), w.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: n, from: s } = e;
+    n = c.obj(n) ? n[t] : n, (n == null || Je(n)) && (n = void 0), s = c.obj(s) ? s[t] : s, s == null && (s = void 0);
+    const i = { to: n, from: s };
+    return Ge(this) || (e.reverse && ([n, s] = [s, n]), s = E(s), c.und(s) ? L(this) || this._set(n) : this._set(s)), i;
+  }
+  /** Every update is processed by this method before merging. */
+  _update({ ...e }, t) {
+    const { key: n, defaultProps: s } = this;
+    e.default && Object.assign(
+      s,
+      pt(
+        e,
+        (a, u) => /^on/.test(u) ? mn(a, n) : a
+      )
+    ), jt(this, e, "onProps"), oe(this, "onProps", e, this);
+    const i = 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 r = this._state;
+    return vn(++this._lastCallId, {
+      key: n,
+      props: e,
+      defaultProps: s,
+      state: r,
+      actions: {
+        pause: () => {
+          re(this) || (Dt(this, !0), ue(r.pauseQueue), oe(
+            this,
+            "onPause",
+            D(this, ae(this, this.animation.to)),
+            this
+          ));
+        },
+        resume: () => {
+          re(this) && (Dt(this, !1), B(this) && this._resume(), ue(r.resumeQueue), oe(
+            this,
+            "onResume",
+            D(this, ae(this, this.animation.to)),
+            this
+          ));
+        },
+        start: this._merge.bind(this, i)
+      }
+    }).then((a) => {
+      if (e.loop && a.finished && !(t && a.noop)) {
+        const u = Pn(e);
+        if (u)
+          return this._update(u, !0);
+      }
+      return a;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(e, t, n) {
+    if (t.cancel)
+      return this.stop(!0), n(ne(this));
+    const s = !c.und(e.to), i = !c.und(e.from);
+    if (s || i)
+      if (t.callId > this._lastToId)
+        this._lastToId = t.callId;
+      else
+        return n(ne(this));
+    const { key: r, defaultProps: a, animation: u } = this, { to: l, from: o } = u;
+    let { to: m = l, from: d = o } = e;
+    i && !s && (!t.default || c.und(m)) && (m = d), t.reverse && ([m, d] = [d, m]);
+    const h = !G(d, o);
+    h && (u.from = d), d = E(d);
+    const g = !G(m, l);
+    g && this._focus(m);
+    const _ = Je(t.to), { config: y } = u, { decay: p, velocity: f } = y;
+    (s || i) && (y.velocity = 0), t.config && !_ && Qs(
+      y,
+      Z(t.config, r),
+      // Avoid calling the same "config" prop twice.
+      t.config !== a.config ? Z(a.config, r) : void 0
+    );
+    let b = L(this);
+    if (!b || c.und(m))
+      return n(D(this, !0));
+    const v = (
+      // 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) ? i && !t.default : !c.und(d) && de(t.reset, r)
+    ), A = v ? d : this.get(), S = ye(m), k = c.num(S) || c.arr(S) || qe(S), x = !_ && (!k || de(a.immediate || t.immediate, r));
+    if (g) {
+      const C = Xe(m);
+      if (C !== b.constructor)
+        if (x)
+          b = this._set(S);
+        else
+          throw Error(
+            `Cannot animate between ${b.constructor.name} and ${C.name}, as the "to" prop suggests`
+          );
+    }
+    const F = b.constructor;
+    let I = V(m), R = !1;
+    if (!I) {
+      const C = v || !Ge(this) && h;
+      (g || C) && (R = G(ye(A), S), I = !R), (!G(u.immediate, x) && !x || !G(y.decay, p) || !G(y.velocity, f)) && (I = !0);
+    }
+    if (R && B(this) && (u.changed && !v ? I = !0 : I || this._stop(l)), !_ && ((I || V(l)) && (u.values = b.getPayload(), u.toValues = V(m) ? null : F == Te ? [1] : O(S)), u.immediate != x && (u.immediate = x, !x && !v && this._set(l)), I)) {
+      const { onRest: C } = u;
+      P(Ws, (z) => jt(this, t, z));
+      const $ = D(this, ae(this, l));
+      ue(this._pendingCalls, $), this._pendingCalls.add(n), u.changed && w.batchedUpdates(() => {
+        var z;
+        u.changed = !v, C == null || C($, this), v ? Z(a.onRest, $) : (z = u.onStart) == null || z.call(u, $, this);
+      });
+    }
+    v && this._set(A), _ ? n(_n(t.to, t, this._state, this)) : I ? this._start() : B(this) && !g ? this._pendingCalls.add(n) : n(yn(A));
+  }
+  /** Update the `animation.to` value, which might be a `FluidValue` */
+  _focus(e) {
+    const t = this.animation;
+    e !== t.to && (Rt(this) && this._detach(), t.to = e, Rt(this) && this._attach());
+  }
+  _attach() {
+    let e = 0;
+    const { to: t } = this.animation;
+    V(t) && (ie(t, this), tt(t) && (e = t.priority + 1)), this.priority = e;
+  }
+  _detach() {
+    const { to: e } = this.animation;
+    V(e) && ge(e, this);
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(e, t = !0) {
+    const n = E(e);
+    if (!c.und(n)) {
+      const s = L(this);
+      if (!s || !G(n, s.getValue())) {
+        const i = Xe(n);
+        !s || s.constructor != i ? mt(this, i.create(n)) : s.setValue(n), s && w.batchedUpdates(() => {
+          this._onChange(n, t);
+        });
+      }
+    }
+    return L(this);
+  }
+  _onStart() {
+    const e = this.animation;
+    e.changed || (e.changed = !0, oe(
+      this,
+      "onStart",
+      D(this, ae(this, e.to)),
+      this
+    ));
+  }
+  _onChange(e, t) {
+    t || (this._onStart(), Z(this.animation.onChange, e, this)), Z(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;
+    L(this).reset(E(e.to)), e.immediate || (e.fromValues = e.values.map((t) => t.lastPosition)), B(this) || (Ut(this, !0), re(this) || this._resume());
+  }
+  _resume() {
+    j.skipAnimation ? this.finish() : Ne.start(this);
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(e, t) {
+    if (B(this)) {
+      Ut(this, !1);
+      const n = this.animation;
+      P(n.values, (i) => {
+        i.done = !0;
+      }), n.toValues && (n.onChange = n.onPause = n.onResume = void 0), pe(this, {
+        type: "idle",
+        parent: this
+      });
+      const s = t ? ne(this.get()) : D(this.get(), ae(this, e ?? n.to));
+      ue(this._pendingCalls, s), n.changed && (n.changed = !1, oe(this, "onRest", s, this));
+    }
+  }
+};
+function ae(e, t) {
+  const n = ye(t), s = ye(e.get());
+  return G(s, n);
+}
+function Pn(e, t = e.loop, n = e.to) {
+  const s = Z(t);
+  if (s) {
+    const i = s !== !0 && gn(s), r = (i || e).reverse, a = !i || i.reset;
+    return be({
+      ...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: !r || Je(n) ? n : 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.
+      ...i
+    });
+  }
+}
+function be(e) {
+  const { to: t, from: n } = e = gn(e), s = /* @__PURE__ */ new Set();
+  return c.obj(t) && qt(t, s), c.obj(n) && qt(n, s), e.keys = s.size ? Array.from(s) : null, e;
+}
+function Hs(e) {
+  const t = be(e);
+  return c.und(t.default) && (t.default = pt(t)), t;
+}
+function qt(e, t) {
+  Q(e, (n, s) => n != null && t.add(s));
+}
+var Ws = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function jt(e, t, n) {
+  e.animation[n] = t[n] !== pn(t, n) ? mn(t[n], e.key) : void 0;
+}
+function oe(e, t, ...n) {
+  var s, i, r, a;
+  (i = (s = e.animation)[t]) == null || i.call(s, ...n), (a = (r = e.defaultProps)[t]) == null || a.call(r, ...n);
+}
+var Ks = ["onStart", "onChange", "onRest"], Ys = 1, Zs = class {
+  constructor(e, t) {
+    this.id = Ys++, 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, n) => e[n] = t.get()), e;
+  }
+  /** Set the current values without animating. */
+  set(e) {
+    for (const t in e) {
+      const n = e[t];
+      c.und(n) || this.springs[t].set(n);
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(e) {
+    return e && this.queue.push(be(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 = O(e).map(be) : this.queue = [], this._flush ? this._flush(this, t) : (Cn(this, t), nt(this, t));
+  }
+  /** @internal */
+  stop(e, t) {
+    if (e !== !!e && (t = e), t) {
+      const n = this.springs;
+      P(O(t), (s) => n[s].stop(!!e));
+    } else
+      _e(this._state, this._lastAsyncId), this.each((n) => n.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;
+      P(O(e), (n) => t[n].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(e) {
+    if (c.und(e))
+      this.start({ pause: !1 });
+    else {
+      const t = this.springs;
+      P(O(e), (n) => t[n].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(e) {
+    Q(this.springs, e);
+  }
+  /** @internal Called at the end of every animation frame */
+  _onFrame() {
+    const { onStart: e, onChange: t, onRest: n } = this._events, s = this._active.size > 0, i = this._changed.size > 0;
+    (s && !this._started || i && !this._started) && (this._started = !0, ce(e, ([u, l]) => {
+      l.value = this.get(), u(l, this, this._item);
+    }));
+    const r = !s && this._started, a = i || r && n.size ? this.get() : null;
+    i && t.size && ce(t, ([u, l]) => {
+      l.value = a, u(l, this, this._item);
+    }), r && (this._started = !1, ce(n, ([u, l]) => {
+      l.value = a, u(l, 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;
+    w.onFrame(this._onFrame);
+  }
+};
+function nt(e, t) {
+  return Promise.all(t.map((n) => Sn(e, n))).then(
+    (n) => gt(e, n)
+  );
+}
+async function Sn(e, t, n) {
+  const { keys: s, to: i, from: r, loop: a, onRest: u, onResolve: l } = t, o = c.obj(t.default) && t.default;
+  a && (t.loop = !1), i === !1 && (t.to = null), r === !1 && (t.from = null);
+  const m = c.arr(i) || c.fun(i) ? i : void 0;
+  m ? (t.to = void 0, t.onRest = void 0, o && (o.onRest = void 0)) : P(Ks, (y) => {
+    const p = t[y];
+    if (c.fun(p)) {
+      const f = e._events[y];
+      t[y] = ({ finished: b, cancelled: v }) => {
+        const A = f.get(p);
+        A ? (b || (A.finished = !1), v && (A.cancelled = !0)) : f.set(p, {
+          value: null,
+          finished: b || !1,
+          cancelled: v || !1
+        });
+      }, o && (o[y] = t[y]);
+    }
+  });
+  const d = e._state;
+  t.pause === !d.paused ? (d.paused = t.pause, ue(t.pause ? d.pauseQueue : d.resumeQueue)) : d.paused && (t.pause = !0);
+  const h = (s || Object.keys(e.springs)).map(
+    (y) => e.springs[y].start(t)
+  ), g = t.cancel === !0 || pn(t, "cancel") === !0;
+  (m || g && d.asyncId) && h.push(
+    vn(++e._lastAsyncId, {
+      props: t,
+      state: d,
+      actions: {
+        pause: Ye,
+        resume: Ye,
+        start(y, p) {
+          g ? (_e(d, e._lastAsyncId), p(ne(e))) : (y.onRest = u, p(
+            _n(
+              m,
+              y,
+              d,
+              e
+            )
+          ));
+        }
+      }
+    })
+  ), d.paused && await new Promise((y) => {
+    d.resumeQueue.add(y);
+  });
+  const _ = gt(e, await Promise.all(h));
+  if (a && _.finished && !(n && _.noop)) {
+    const y = Pn(t, a, i);
+    if (y)
+      return Cn(e, [y]), Sn(e, y, !0);
+  }
+  return l && w.batchedUpdates(() => l(_, e, e.item)), _;
+}
+function $t(e, t) {
+  const n = { ...e.springs };
+  return t && P(O(t), (s) => {
+    c.und(s.keys) && (s = be(s)), c.obj(s.to) || (s = { ...s, to: void 0 }), xn(n, s, (i) => Rn(i));
+  }), In(e, n), n;
+}
+function In(e, t) {
+  Q(t, (n, s) => {
+    e.springs[s] || (e.springs[s] = n, ie(n, e));
+  });
+}
+function Rn(e, t) {
+  const n = new Bs();
+  return n.key = e, t && ie(n, t), n;
+}
+function xn(e, t, n) {
+  t.keys && P(t.keys, (s) => {
+    (e[s] || (e[s] = n(s)))._prepareNode(t);
+  });
+}
+function Cn(e, t) {
+  P(t, (n) => {
+    xn(e.springs, n, (s) => Rn(s, e));
+  });
+}
+var Xs = Qt.createContext({
+  pause: !1,
+  immediate: !1
+}), Js = () => {
+  const e = [], t = function(s) {
+    Ss();
+    const i = [];
+    return P(e, (r, a) => {
+      if (c.und(s))
+        i.push(r.start());
+      else {
+        const u = n(s, r, a);
+        u && i.push(r.start(u));
+      }
+    }), i;
+  };
+  t.current = e, t.add = function(s) {
+    e.includes(s) || e.push(s);
+  }, t.delete = function(s) {
+    const i = e.indexOf(s);
+    ~i && e.splice(i, 1);
+  }, t.pause = function() {
+    return P(e, (s) => s.pause(...arguments)), this;
+  }, t.resume = function() {
+    return P(e, (s) => s.resume(...arguments)), this;
+  }, t.set = function(s) {
+    P(e, (i, r) => {
+      const a = c.fun(s) ? s(r, i) : s;
+      a && i.set(a);
+    });
+  }, t.start = function(s) {
+    const i = [];
+    return P(e, (r, a) => {
+      if (c.und(s))
+        i.push(r.start());
+      else {
+        const u = this._getProps(s, r, a);
+        u && i.push(r.start(u));
+      }
+    }), i;
+  }, t.stop = function() {
+    return P(e, (s) => s.stop(...arguments)), this;
+  }, t.update = function(s) {
+    return P(e, (i, r) => i.update(this._getProps(s, i, r))), this;
+  };
+  const n = function(s, i, r) {
+    return c.fun(s) ? s(r, i) : s;
+  };
+  return t._getProps = n, t;
+};
+function ei(e, t, n) {
+  const s = c.fun(t) && t;
+  s && !n && (n = []);
+  const i = Pe(
+    () => s || arguments.length == 3 ? Js() : void 0,
+    []
+  ), r = K(0), a = un(), u = Pe(
+    () => ({
+      ctrls: [],
+      queue: [],
+      flush(f, b) {
+        const v = $t(f, b);
+        return r.current > 0 && !u.queue.length && !Object.keys(v).some((S) => !f.springs[S]) ? nt(f, b) : new Promise((S) => {
+          In(f, v), u.queue.push(() => {
+            S(nt(f, b));
+          }), a();
+        });
+      }
+    }),
+    []
+  ), l = K([...u.ctrls]), o = K([]), m = Ct(e) || 0;
+  Pe(() => {
+    P(l.current.slice(e, m), (f) => {
+      js(f, i), f.stop(!0);
+    }), l.current.length = e, d(m, e);
+  }, [e]), Pe(() => {
+    d(0, Math.min(m, e));
+  }, n);
+  function d(f, b) {
+    for (let v = f; v < b; v++) {
+      const A = l.current[v] || (l.current[v] = new Zs(null, u.flush)), S = s ? s(v, A) : t[v];
+      S && (o.current[v] = Hs(S));
+    }
+  }
+  const h = l.current.map(
+    (f, b) => $t(f, o.current[b])
+  ), g = Dn(Xs), _ = Ct(g), y = g !== _ && qs(g);
+  ht(() => {
+    r.current++, u.ctrls = l.current;
+    const { queue: f } = u;
+    f.length && (u.queue = [], P(f, (b) => b())), P(l.current, (b, v) => {
+      i == null || i.add(b), y && b.start({ default: g });
+      const A = o.current[v];
+      A && ($s(b, A.ref), b.ref ? b.queue.push(A) : b.start(A));
+    });
+  }), cn(() => () => {
+    P(u.ctrls, (f) => f.stop(!0));
+  });
+  const p = h.map((f) => ({ ...f }));
+  return i ? [p, i] : p;
+}
+function ti(e, t) {
+  const n = c.fun(e), [[s], i] = ei(
+    1,
+    n ? e : [e],
+    n ? [] : t
+  );
+  return n || arguments.length == 2 ? [s, i] : s;
+}
+var ni = class extends vt {
+  constructor(e, t) {
+    super(), this.source = e, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = he(...t);
+    const n = this._get(), s = Xe(n);
+    mt(this, s.create(n));
+  }
+  advance(e) {
+    const t = this._get(), n = this.get();
+    G(t, n) || (L(this).setValue(t), this._onChange(t, this.idle)), !this.idle && zt(this._active) && Be(this);
+  }
+  _get() {
+    const e = c.arr(this.source) ? this.source.map(E) : O(E(this.source));
+    return this.calc(...e);
+  }
+  _start() {
+    this.idle && !zt(this._active) && (this.idle = !1, P(je(this), (e) => {
+      e.done = !1;
+    }), j.skipAnimation ? (w.batchedUpdates(() => this.advance()), Be(this)) : Ne.start(this));
+  }
+  // Observe our sources only when we're observed.
+  _attach() {
+    let e = 1;
+    P(O(this.source), (t) => {
+      V(t) && ie(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(O(this.source), (e) => {
+      V(e) && ge(e, this);
+    }), this._active.clear(), Be(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 = O(this.source).reduce(
+      (t, n) => Math.max(t, (tt(n) ? n.priority : 0) + 1),
+      0
+    ));
+  }
+};
+function si(e) {
+  return e.idle !== !1;
+}
+function zt(e) {
+  return !e.size || Array.from(e).every(si);
+}
+function Be(e) {
+  e.idle || (e.idle = !0, P(je(e), (t) => {
+    t.done = !0;
+  }), pe(e, {
+    type: "idle",
+    parent: e
+  }));
+}
+j.assign({
+  createStringInterpolator: an,
+  to: (e, t) => new ni(e, t)
+});
+var kn = /^--/;
+function ii(e, t) {
+  return t == null || typeof t == "boolean" || t === "" ? "" : typeof t == "number" && t !== 0 && !kn.test(e) && !(fe.hasOwnProperty(e) && fe[e]) ? t + "px" : ("" + t).trim();
+}
+var Lt = {};
+function ri(e, t) {
+  if (!e.nodeType || !e.setAttribute)
+    return !1;
+  const n = e.nodeName === "filter" || e.parentNode && e.parentNode.nodeName === "filter", {
+    className: s,
+    style: i,
+    children: r,
+    scrollTop: a,
+    scrollLeft: u,
+    viewBox: l,
+    ...o
+  } = t, m = Object.values(o), d = Object.keys(o).map(
+    (h) => n || e.hasAttribute(h) ? h : Lt[h] || (Lt[h] = h.replace(
+      /([A-Z])/g,
+      // Attributes are written in dash case
+      (g) => "-" + g.toLowerCase()
+    ))
+  );
+  r !== void 0 && (e.textContent = r);
+  for (const h in i)
+    if (i.hasOwnProperty(h)) {
+      const g = ii(h, i[h]);
+      kn.test(h) ? e.style.setProperty(h, g) : e.style[h] = g;
+    }
+  d.forEach((h, g) => {
+    e.setAttribute(h, m[g]);
+  }), s !== void 0 && (e.className = s), a !== void 0 && (e.scrollTop = a), u !== void 0 && (e.scrollLeft = u), l !== void 0 && e.setAttribute("viewBox", l);
+}
+var fe = {
+  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
+}, ai = (e, t) => e + t.charAt(0).toUpperCase() + t.substring(1), oi = ["Webkit", "Ms", "Moz", "O"];
+fe = Object.keys(fe).reduce((e, t) => (oi.forEach((n) => e[ai(n, t)] = e[t]), e), fe);
+var ui = /^(matrix|translate|scale|rotate|skew)/, ci = /^(translate)/, li = /^(rotate|skew)/, He = (e, t) => c.num(e) && e !== 0 ? e + t : e, Ce = (e, t) => c.arr(e) ? e.every((n) => Ce(n, t)) : c.num(e) ? e === t : parseFloat(e) === t, di = class extends ze {
+  constructor({ x: e, y: t, z: n, ...s }) {
+    const i = [], r = [];
+    (e || t || n) && (i.push([e || 0, t || 0, n || 0]), r.push((a) => [
+      `translate3d(${a.map((u) => He(u, "px")).join(",")})`,
+      // prettier-ignore
+      Ce(a, 0)
+    ])), Q(s, (a, u) => {
+      if (u === "transform")
+        i.push([a || ""]), r.push((l) => [l, l === ""]);
+      else if (ui.test(u)) {
+        if (delete s[u], c.und(a)) return;
+        const l = ci.test(u) ? "px" : li.test(u) ? "deg" : "";
+        i.push(O(a)), r.push(
+          u === "rotate3d" ? ([o, m, d, h]) => [
+            `rotate3d(${o},${m},${d},${He(h, l)})`,
+            Ce(h, 0)
+          ] : (o) => [
+            `${u}(${o.map((m) => He(m, l)).join(",")})`,
+            Ce(o, u.startsWith("scale") ? 1 : 0)
+          ]
+        );
+      }
+    }), i.length && (s.transform = new fi(i, r)), super(s);
+  }
+}, fi = class extends nn {
+  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, (n, s) => {
+      const i = E(n[0]), [r, a] = this.transforms[s](
+        c.arr(i) ? i : n.map(E)
+      );
+      e += " " + r, 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,
+        (n) => V(n) && ie(n, this)
+      )
+    );
+  }
+  // Stop observing our inputs once we have no observers.
+  observerRemoved(e) {
+    e == 0 && P(
+      this.inputs,
+      (t) => P(
+        t,
+        (n) => V(n) && ge(n, this)
+      )
+    );
+  }
+  eventObserved(e) {
+    e.type == "change" && (this._value = null), pe(this, e);
+  }
+}, hi = [
+  "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"
+];
+j.assign({
+  batchedUpdates: zn,
+  createStringInterpolator: an,
+  colors: ss
+});
+var mi = Os(hi, {
+  applyAnimatedValues: ri,
+  createAnimatedStyle: (e) => new di(e),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getComponentProps: ({ scrollTop: e, scrollLeft: t, ...n }) => n
+}), pi = mi.animated;
+const gi = "_content_12gg8_1", vi = {
+  content: gi
+}, Fn = "ContextMenu.Content", yi = st(
+  ({
+    style: e,
+    className: t,
+    children: n,
+    alignOffset: s,
+    arrowPadding: i = 5,
+    collisionBoundary: r,
+    direction: a = T.DOWN_RIGHT,
+    disableAutoPositioning: u = !1,
+    disableRepositioning: l = !1,
+    onMouseEnter: o,
+    onMouseLeave: m,
+    onInteractOutside: d,
+    onEscapeKeyDown: h,
+    ...g
+  }, _) => {
+    const [y, p] = ee(!1), [f, b] = ee(null), {
+      triggerRef: v,
+      contentRef: A,
+      isOpen: S,
+      animatedOpen: k,
+      animationDuration: x,
+      mode: F,
+      temporaryHoverClose: I,
+      onMouseEnter: R,
+      onMouseLeave: C,
+      onChildOpen: $,
+      isRootContentBlocked: z,
+      isChildOpen: M,
+      closeMenuImmediately: Tn,
+      isCloseOnClick: En
+    } = Mn(Fn), { align: On, offset: Vn, isPositioned: yt } = _i({
+      direction: a,
+      alignOffset: s,
+      disableAutoPositioning: u,
+      triggerRef: v,
+      contentRef: A,
+      collisionBoundary: r,
+      children: n,
+      disableRepositioning: l
+    }), Nn = ti({
+      opacity: yt && (F === _t.CLICK && !I || k) ? 1 : 0,
+      config: F === _t.CLICK && !I ? { duration: 0 } : { duration: x, easing: tn.easeInOutCubic }
+    });
+    return /* @__PURE__ */ Re(
+      Qn,
+      {
+        hasItemWithIcon: y,
+        setHasItemWithIcon: p,
+        activeItemId: f,
+        setActiveItemId: b,
+        onChildOpen: $,
+        isCloseOnClick: En,
+        closeMenuImmediately: Tn,
+        shouldCloseRootMenuOnClick: !1,
+        level: 1,
+        children: S && /* @__PURE__ */ Re(
+          pi.div,
+          {
+            style: {
+              zIndex: Number.MAX_SAFE_INTEGER - 10,
+              position: "fixed",
+              ...Nn
+            },
+            "data-content-wrapper": !0,
+            children: /* @__PURE__ */ qn(
+              jn,
+              {
+                ref: Ln(A, _),
+                className: Mt(vi.content, t),
+                style: {
+                  ...e || {},
+                  pointerEvents: u || yt ? "auto" : "none"
+                },
+                collisionBoundary: r,
+                side: Gn[a],
+                align: On,
+                arrowPadding: i,
+                alignOffset: Vn,
+                onMouseEnter: (U) => {
+                  R == null || R(U), o == null || o(U);
+                },
+                onMouseLeave: (U) => {
+                  C == null || C(U), m == null || m(U);
+                },
+                onInteractOutside: (U) => {
+                  M && U.preventDefault(), d == null || d(U);
+                },
+                onEscapeKeyDown: (U) => {
+                  M && U.preventDefault(), h == null || h(U);
+                },
+                ...g,
+                children: [
+                  n,
+                  z && /* @__PURE__ */ Re(Gt, {})
+                ]
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+yi.displayName = Fn;
+function _i({
+  direction: e,
+  alignOffset: t = 0,
+  disableAutoPositioning: n,
+  triggerRef: s,
+  contentRef: i,
+  collisionBoundary: r,
+  disableRepositioning: a,
+  children: u
+}) {
+  const [l, o] = ee(
+    e === T.UP_RIGHT || e === T.DOWN_RIGHT || e === T.RIGHT_DOWN || e === T.LEFT_DOWN || !e ? "start" : "end"
+  ), [m, d] = ee(t), [h, g] = ee(!1), _ = K(!1), y = Hn(l);
+  return We(() => {
+    if (n || !(s != null && s.current) || !e)
+      return;
+    let p = null, f = !0;
+    const b = r instanceof Element && r || document.documentElement, v = () => {
+      if (!f)
+        return;
+      const A = s.current, S = i.current;
+      if (!A || !S)
+        return;
+      const k = A.getBoundingClientRect(), x = S.getBoundingClientRect();
+      if (x.width <= 0)
+        return;
+      const F = b.getBoundingClientRect(), I = {
+        right: F.right - k.right >= x.width,
+        left: k.left - F.left >= x.width,
+        bottom: F.bottom - k.bottom >= x.height,
+        top: k.top - F.top >= x.height
+      };
+      let R = "start";
+      switch (e) {
+        case T.UP_RIGHT:
+        case T.DOWN_RIGHT: {
+          I.right ? R = "start" : I.left ? R = "end" : R = "start";
+          break;
+        }
+        case T.UP_LEFT:
+        case T.DOWN_LEFT: {
+          I.left ? R = "end" : I.right ? R = "start" : R = "end";
+          break;
+        }
+        case T.RIGHT_DOWN:
+        case T.LEFT_DOWN: {
+          I.bottom ? R = "start" : I.top ? R = "end" : R = "start";
+          break;
+        }
+        case T.RIGHT_UP:
+        case T.LEFT_UP: {
+          I.top ? R = "end" : I.bottom ? R = "start" : R = "end";
+          break;
+        }
+      }
+      o(R), g(!0);
+    };
+    return requestAnimationFrame(v), !a && i.current && typeof ResizeObserver < "u" && (p = new ResizeObserver(v), p.observe(i.current)), () => {
+      f = !1, p == null || p.disconnect();
+    };
+  }, [
+    e,
+    n,
+    a,
+    s,
+    i,
+    r
+  ]), We(() => {
+    const p = i == null ? void 0 : i.current, f = s == null ? void 0 : s.current;
+    if (a && _.current && y === l || !p || !f || n || [
+      T.DOWN_LEFT,
+      T.DOWN_RIGHT,
+      T.UP_LEFT,
+      T.UP_RIGHT
+    ].includes(e))
+      return;
+    const b = Array.from(p.querySelectorAll("[data-item]"));
+    if (b.length === 0)
+      return;
+    const v = l === "start" ? b[0] : b[b.length - 1], A = () => {
+      const k = f.getBoundingClientRect(), x = p.getBoundingClientRect(), F = v.getBoundingClientRect(), I = (M) => !M.width || !M.height || !isFinite(M.top) || !isFinite(M.left);
+      if ([k, x, F].some(I)) {
+        requestAnimationFrame(A);
+        return;
+      }
+      const R = k.height / 2, C = F.height / 2, $ = F.top - x.top, z = F.bottom - x.bottom;
+      d(l === "start" ? t + R - $ - C : t + R + z - C), _.current = !0;
+    };
+    if (requestAnimationFrame(A), a)
+      return;
+    const S = new ResizeObserver(() => {
+      requestAnimationFrame(A);
+    });
+    return S.observe(v), S.observe(f), () => S.disconnect();
+  }, [
+    u,
+    e,
+    a,
+    l,
+    i,
+    s,
+    l,
+    t,
+    n
+  ]), { align: l, offset: m, isPositioned: h };
+}
+export {
+  yi as C,
+  Gt as F,
+  ti as a,
+  pi as b,
+  bt as c,
+  tn as e,
+  _i as u
+};