@telegraph/tooltip 0.0.50 → 0.0.52

package/dist/esm/index.mjs

@@ -1,138 +1,3397 @@
-import { jsx as t, jsxs as w } from "react/jsx-runtime";
-import * as p from "@radix-ui/react-tooltip";
-import { useControllableState as B } from "@radix-ui/react-use-controllable-state";
-import { OverrideAppearance as q } from "@telegraph/appearance";
-import { RefToTgphRef as H } from "@telegraph/helpers";
-import { Stack as J } from "@telegraph/layout";
-import { motion as K } from "@telegraph/motion";
-import { Text as L } from "@telegraph/typography";
-import a from "react";
-const Q = {
+import { jsx as I, jsxs as hn } from "react/jsx-runtime";
+import * as at from "@radix-ui/react-tooltip";
+import { useControllableState as Os } from "@radix-ui/react-use-controllable-state";
+import { OverrideAppearance as Ds } from "@telegraph/appearance";
+import { RefToTgphRef as Rs } from "@telegraph/helpers";
+import { Stack as Is } from "@telegraph/layout";
+import { Text as Es } from "@telegraph/typography";
+import ft, { createContext as Q, useRef as ct, useLayoutEffect as ks, useEffect as ce, useState as Ns, useContext as k, useMemo as Rt, useCallback as Ls, useInsertionEffect as Bs, forwardRef as Ks, Fragment as pn, createElement as Ws } from "react";
+const $s = Q({});
+function js(t) {
+  const e = ct(null);
+  return e.current === null && (e.current = t()), e.current;
+}
+const le = typeof window < "u", Gs = le ? ks : ce, mn = /* @__PURE__ */ Q(null);
+function _s(t, e) {
+  t.indexOf(e) === -1 && t.push(e);
+}
+function Us(t, e) {
+  const n = t.indexOf(e);
+  n > -1 && t.splice(n, 1);
+}
+const Y = (t, e, n) => n > e ? e : n < t ? t : n;
+let tt = () => {
+}, j = () => {
+};
+process.env.NODE_ENV !== "production" && (tt = (t, e) => {
+  !t && typeof console < "u" && console.warn(e);
+}, j = (t, e) => {
+  if (!t)
+    throw new Error(e);
+});
+const W = {}, gn = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t);
+function Hs(t) {
+  return typeof t == "object" && t !== null;
+}
+const yn = (t) => /^0[^.\s]+$/u.test(t);
+// @__NO_SIDE_EFFECTS__
+function fe(t) {
+  let e;
+  return () => (e === void 0 && (e = t()), e);
+}
+const et = /* @__NO_SIDE_EFFECTS__ */ (t) => t, zs = (t, e) => (n) => e(t(n)), It = (...t) => t.reduce(zs), bn = /* @__NO_SIDE_EFFECTS__ */ (t, e, n) => {
+  const s = e - t;
+  return s === 0 ? 1 : (n - t) / s;
+};
+class Tn {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(e) {
+    return _s(this.subscriptions, e), () => Us(this.subscriptions, e);
+  }
+  notify(e, n, s) {
+    const i = this.subscriptions.length;
+    if (i)
+      if (i === 1)
+        this.subscriptions[0](e, n, s);
+      else
+        for (let r = 0; r < i; r++) {
+          const o = this.subscriptions[r];
+          o && o(e, n, s);
+        }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}
+const L = /* @__NO_SIDE_EFFECTS__ */ (t) => t * 1e3, K = /* @__NO_SIDE_EFFECTS__ */ (t) => t / 1e3;
+function vn(t, e) {
+  return e ? t * (1e3 / e) : 0;
+}
+const ke = /* @__PURE__ */ new Set();
+function wn(t, e, n) {
+  t || ke.has(e) || (console.warn(e), ke.add(e));
+}
+const Sn = (t, e, n) => (((1 - 3 * n + 3 * e) * t + (3 * n - 6 * e)) * t + 3 * e) * t, Ys = 1e-7, Xs = 12;
+function qs(t, e, n, s, i) {
+  let r, o, a = 0;
+  do
+    o = e + (n - e) / 2, r = Sn(o, s, i) - t, r > 0 ? n = o : e = o;
+  while (Math.abs(r) > Ys && ++a < Xs);
+  return o;
+}
+function gt(t, e, n, s) {
+  if (t === e && n === s)
+    return et;
+  const i = (r) => qs(r, 0, 1, t, n);
+  return (r) => r === 0 || r === 1 ? r : Sn(i(r), e, s);
+}
+const Vn = (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, An = (t) => (e) => 1 - t(1 - e), xn = /* @__PURE__ */ gt(0.33, 1.53, 0.69, 0.99), de = /* @__PURE__ */ An(xn), Mn = /* @__PURE__ */ Vn(de), Cn = (t) => (t *= 2) < 1 ? 0.5 * de(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), he = (t) => 1 - Math.sin(Math.acos(t)), Zs = An(he), Pn = Vn(he), Js = /* @__PURE__ */ gt(0.42, 0, 1, 1), Qs = /* @__PURE__ */ gt(0, 0, 0.58, 1), Fn = /* @__PURE__ */ gt(0.42, 0, 0.58, 1), ti = (t) => Array.isArray(t) && typeof t[0] != "number", On = (t) => Array.isArray(t) && typeof t[0] == "number", Ne = {
+  linear: et,
+  easeIn: Js,
+  easeInOut: Fn,
+  easeOut: Qs,
+  circIn: he,
+  circInOut: Pn,
+  circOut: Zs,
+  backIn: de,
+  backInOut: Mn,
+  backOut: xn,
+  anticipate: Cn
+}, ei = (t) => typeof t == "string", Le = (t) => {
+  if (On(t)) {
+    j(t.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [e, n, s, i] = t;
+    return gt(e, n, s, i);
+  } else if (ei(t))
+    return j(Ne[t] !== void 0, `Invalid easing type '${t}'`), Ne[t];
+  return t;
+}, St = [
+  "setup",
+  // Compute
+  "read",
+  // Read
+  "resolveKeyframes",
+  // Write/Read/Write/Read
+  "preUpdate",
+  // Compute
+  "update",
+  // Compute
+  "preRender",
+  // Compute
+  "render",
+  // Write
+  "postRender"
+  // Compute
+];
+function ni(t, e) {
+  let n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), i = !1, r = !1;
+  const o = /* @__PURE__ */ new WeakSet();
+  let a = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  };
+  function c(u) {
+    o.has(u) && (l.schedule(u), t()), u(a);
+  }
+  const l = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (u, d = !1, f = !1) => {
+      const y = f && i ? n : s;
+      return d && o.add(u), y.has(u) || y.add(u), u;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (u) => {
+      s.delete(u), o.delete(u);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (u) => {
+      if (a = u, i) {
+        r = !0;
+        return;
+      }
+      i = !0, [n, s] = [s, n], n.forEach(c), n.clear(), i = !1, r && (r = !1, l.process(u));
+    }
+  };
+  return l;
+}
+const si = 40;
+function Dn(t, e) {
+  let n = !1, s = !0;
+  const i = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, r = () => n = !0, o = St.reduce((m, A) => (m[A] = ni(r), m), {}), { setup: a, read: c, resolveKeyframes: l, preUpdate: u, update: d, preRender: f, render: h, postRender: y } = o, b = () => {
+    const m = W.useManualTiming ? i.timestamp : performance.now();
+    n = !1, W.useManualTiming || (i.delta = s ? 1e3 / 60 : Math.max(Math.min(m - i.timestamp, si), 1)), i.timestamp = m, i.isProcessing = !0, a.process(i), c.process(i), l.process(i), u.process(i), d.process(i), f.process(i), h.process(i), y.process(i), i.isProcessing = !1, n && e && (s = !1, t(b));
+  }, v = () => {
+    n = !0, s = !0, i.isProcessing || t(b);
+  };
+  return { schedule: St.reduce((m, A) => {
+    const T = o[A];
+    return m[A] = (V, M = !1, w = !1) => (n || v(), T.schedule(V, M, w)), m;
+  }, {}), cancel: (m) => {
+    for (let A = 0; A < St.length; A++)
+      o[St[A]].cancel(m);
+  }, state: i, steps: o };
+}
+const { schedule: N, cancel: Ut, state: Mt, steps: Ba } = /* @__PURE__ */ Dn(typeof requestAnimationFrame < "u" ? requestAnimationFrame : et, !0);
+let At;
+function ii() {
+  At = void 0;
+}
+const E = {
+  now: () => (At === void 0 && E.set(Mt.isProcessing || W.useManualTiming ? Mt.timestamp : performance.now()), At),
+  set: (t) => {
+    At = t, queueMicrotask(ii);
+  }
+}, Rn = (t) => (e) => typeof e == "string" && e.startsWith(t), In = /* @__PURE__ */ Rn("--"), ri = /* @__PURE__ */ Rn("var(--"), pe = (t) => ri(t) ? oi.test(t.split("/*")[0].trim()) : !1, oi = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu, nt = {
+  test: (t) => typeof t == "number",
+  parse: parseFloat,
+  transform: (t) => t
+}, dt = {
+  ...nt,
+  transform: (t) => Y(0, 1, t)
+}, Vt = {
+  ...nt,
+  default: 1
+}, lt = (t) => Math.round(t * 1e5) / 1e5, me = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function ai(t) {
+  return t == null;
+}
+const ui = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, ge = (t, e) => (n) => !!(typeof n == "string" && ui.test(n) && n.startsWith(t) || e && !ai(n) && Object.prototype.hasOwnProperty.call(n, e)), En = (t, e, n) => (s) => {
+  if (typeof s != "string")
+    return s;
+  const [i, r, o, a] = s.match(me);
+  return {
+    [t]: parseFloat(i),
+    [e]: parseFloat(r),
+    [n]: parseFloat(o),
+    alpha: a !== void 0 ? parseFloat(a) : 1
+  };
+}, ci = (t) => Y(0, 255, t), Kt = {
+  ...nt,
+  transform: (t) => Math.round(ci(t))
+}, _ = {
+  test: /* @__PURE__ */ ge("rgb", "red"),
+  parse: /* @__PURE__ */ En("red", "green", "blue"),
+  transform: ({ red: t, green: e, blue: n, alpha: s = 1 }) => "rgba(" + Kt.transform(t) + ", " + Kt.transform(e) + ", " + Kt.transform(n) + ", " + lt(dt.transform(s)) + ")"
+};
+function li(t) {
+  let e = "", n = "", s = "", i = "";
+  return t.length > 5 ? (e = t.substring(1, 3), n = t.substring(3, 5), s = t.substring(5, 7), i = t.substring(7, 9)) : (e = t.substring(1, 2), n = t.substring(2, 3), s = t.substring(3, 4), i = t.substring(4, 5), e += e, n += n, s += s, i += i), {
+    red: parseInt(e, 16),
+    green: parseInt(n, 16),
+    blue: parseInt(s, 16),
+    alpha: i ? parseInt(i, 16) / 255 : 1
+  };
+}
+const Ht = {
+  test: /* @__PURE__ */ ge("#"),
+  parse: li,
+  transform: _.transform
+}, yt = /* @__NO_SIDE_EFFECTS__ */ (t) => ({
+  test: (e) => typeof e == "string" && e.endsWith(t) && e.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (e) => `${e}${t}`
+}), $ = /* @__PURE__ */ yt("deg"), Z = /* @__PURE__ */ yt("%"), g = /* @__PURE__ */ yt("px"), fi = /* @__PURE__ */ yt("vh"), di = /* @__PURE__ */ yt("vw"), Be = {
+  ...Z,
+  parse: (t) => Z.parse(t) / 100,
+  transform: (t) => Z.transform(t * 100)
+}, X = {
+  test: /* @__PURE__ */ ge("hsl", "hue"),
+  parse: /* @__PURE__ */ En("hue", "saturation", "lightness"),
+  transform: ({ hue: t, saturation: e, lightness: n, alpha: s = 1 }) => "hsla(" + Math.round(t) + ", " + Z.transform(lt(e)) + ", " + Z.transform(lt(n)) + ", " + lt(dt.transform(s)) + ")"
+}, C = {
+  test: (t) => _.test(t) || Ht.test(t) || X.test(t),
+  parse: (t) => _.test(t) ? _.parse(t) : X.test(t) ? X.parse(t) : Ht.parse(t),
+  transform: (t) => typeof t == "string" ? t : t.hasOwnProperty("red") ? _.transform(t) : X.transform(t),
+  getAnimatableNone: (t) => {
+    const e = C.parse(t);
+    return e.alpha = 0, C.transform(e);
+  }
+}, hi = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+function pi(t) {
+  var e, n;
+  return isNaN(t) && typeof t == "string" && (((e = t.match(me)) == null ? void 0 : e.length) || 0) + (((n = t.match(hi)) == null ? void 0 : n.length) || 0) > 0;
+}
+const kn = "number", Nn = "color", mi = "var", gi = "var(", Ke = "${}", yi = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function ht(t) {
+  const e = t.toString(), n = [], s = {
+    color: [],
+    number: [],
+    var: []
+  }, i = [];
+  let r = 0;
+  const a = e.replace(yi, (c) => (C.test(c) ? (s.color.push(r), i.push(Nn), n.push(C.parse(c))) : c.startsWith(gi) ? (s.var.push(r), i.push(mi), n.push(c)) : (s.number.push(r), i.push(kn), n.push(parseFloat(c))), ++r, Ke)).split(Ke);
+  return { values: n, split: a, indexes: s, types: i };
+}
+function Ln(t) {
+  return ht(t).values;
+}
+function Bn(t) {
+  const { split: e, types: n } = ht(t), s = e.length;
+  return (i) => {
+    let r = "";
+    for (let o = 0; o < s; o++)
+      if (r += e[o], i[o] !== void 0) {
+        const a = n[o];
+        a === kn ? r += lt(i[o]) : a === Nn ? r += C.transform(i[o]) : r += i[o];
+      }
+    return r;
+  };
+}
+const bi = (t) => typeof t == "number" ? 0 : C.test(t) ? C.getAnimatableNone(t) : t;
+function Ti(t) {
+  const e = Ln(t);
+  return Bn(t)(e.map(bi));
+}
+const st = {
+  test: pi,
+  parse: Ln,
+  createTransformer: Bn,
+  getAnimatableNone: Ti
+};
+function Wt(t, e, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? t + (e - t) * 6 * n : n < 1 / 2 ? e : n < 2 / 3 ? t + (e - t) * (2 / 3 - n) * 6 : t;
+}
+function vi({ hue: t, saturation: e, lightness: n, alpha: s }) {
+  t /= 360, e /= 100, n /= 100;
+  let i = 0, r = 0, o = 0;
+  if (!e)
+    i = r = o = n;
+  else {
+    const a = n < 0.5 ? n * (1 + e) : n + e - n * e, c = 2 * n - a;
+    i = Wt(c, a, t + 1 / 3), r = Wt(c, a, t), o = Wt(c, a, t - 1 / 3);
+  }
+  return {
+    red: Math.round(i * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(o * 255),
+    alpha: s
+  };
+}
+function Ct(t, e) {
+  return (n) => n > 0 ? e : t;
+}
+const Et = (t, e, n) => t + (e - t) * n, $t = (t, e, n) => {
+  const s = t * t, i = n * (e * e - s) + s;
+  return i < 0 ? 0 : Math.sqrt(i);
+}, wi = [Ht, _, X], Si = (t) => wi.find((e) => e.test(t));
+function We(t) {
+  const e = Si(t);
+  if (tt(!!e, `'${t}' is not an animatable color. Use the equivalent color code instead.`), !e)
+    return !1;
+  let n = e.parse(t);
+  return e === X && (n = vi(n)), n;
+}
+const $e = (t, e) => {
+  const n = We(t), s = We(e);
+  if (!n || !s)
+    return Ct(t, e);
+  const i = { ...n };
+  return (r) => (i.red = $t(n.red, s.red, r), i.green = $t(n.green, s.green, r), i.blue = $t(n.blue, s.blue, r), i.alpha = Et(n.alpha, s.alpha, r), _.transform(i));
+}, zt = /* @__PURE__ */ new Set(["none", "hidden"]);
+function Vi(t, e) {
+  return zt.has(t) ? (n) => n <= 0 ? t : e : (n) => n >= 1 ? e : t;
+}
+function Ai(t, e) {
+  return (n) => Et(t, e, n);
+}
+function ye(t) {
+  return typeof t == "number" ? Ai : typeof t == "string" ? pe(t) ? Ct : C.test(t) ? $e : Ci : Array.isArray(t) ? Kn : typeof t == "object" ? C.test(t) ? $e : xi : Ct;
+}
+function Kn(t, e) {
+  const n = [...t], s = n.length, i = t.map((r, o) => ye(r)(r, e[o]));
+  return (r) => {
+    for (let o = 0; o < s; o++)
+      n[o] = i[o](r);
+    return n;
+  };
+}
+function xi(t, e) {
+  const n = { ...t, ...e }, s = {};
+  for (const i in n)
+    t[i] !== void 0 && e[i] !== void 0 && (s[i] = ye(t[i])(t[i], e[i]));
+  return (i) => {
+    for (const r in s)
+      n[r] = s[r](i);
+    return n;
+  };
+}
+function Mi(t, e) {
+  const n = [], s = { color: 0, var: 0, number: 0 };
+  for (let i = 0; i < e.values.length; i++) {
+    const r = e.types[i], o = t.indexes[r][s[r]], a = t.values[o] ?? 0;
+    n[i] = a, s[r]++;
+  }
+  return n;
+}
+const Ci = (t, e) => {
+  const n = st.createTransformer(e), s = ht(t), i = ht(e);
+  return s.indexes.var.length === i.indexes.var.length && s.indexes.color.length === i.indexes.color.length && s.indexes.number.length >= i.indexes.number.length ? zt.has(t) && !i.values.length || zt.has(e) && !s.values.length ? Vi(t, e) : It(Kn(Mi(s, i), i.values), n) : (tt(!0, `Complex values '${t}' and '${e}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`), Ct(t, e));
+};
+function Wn(t, e, n) {
+  return typeof t == "number" && typeof e == "number" && typeof n == "number" ? Et(t, e, n) : ye(t)(t, e);
+}
+const Pi = (t) => {
+  const e = ({ timestamp: n }) => t(n);
+  return {
+    start: (n = !0) => N.update(e, n),
+    stop: () => Ut(e),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => Mt.isProcessing ? Mt.timestamp : E.now()
+  };
+}, $n = (t, e, n = 10) => {
+  let s = "";
+  const i = Math.max(Math.round(e / n), 2);
+  for (let r = 0; r < i; r++)
+    s += Math.round(t(r / (i - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${s.substring(0, s.length - 2)})`;
+}, Pt = 2e4;
+function be(t) {
+  let e = 0;
+  const n = 50;
+  let s = t.next(e);
+  for (; !s.done && e < Pt; )
+    e += n, s = t.next(e);
+  return e >= Pt ? 1 / 0 : e;
+}
+function Fi(t, e = 100, n) {
+  const s = n({ ...t, keyframes: [0, e] }), i = Math.min(be(s), Pt);
+  return {
+    type: "keyframes",
+    ease: (r) => s.next(i * r).value / e,
+    duration: /* @__PURE__ */ K(i)
+  };
+}
+const Oi = 5;
+function jn(t, e, n) {
+  const s = Math.max(e - Oi, 0);
+  return vn(n - t(s), e - s);
+}
+const x = {
+  // Default spring physics
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 0,
+  // Default duration/bounce-based options
+  duration: 800,
+  // in ms
+  bounce: 0.3,
+  visualDuration: 0.3,
+  // in seconds
+  // Rest thresholds
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  // Limits
+  minDuration: 0.01,
+  // in seconds
+  maxDuration: 10,
+  // in seconds
+  minDamping: 0.05,
+  maxDamping: 1
+}, je = 1e-3;
+function Di({ duration: t = x.duration, bounce: e = x.bounce, velocity: n = x.velocity, mass: s = x.mass }) {
+  let i, r;
+  tt(t <= /* @__PURE__ */ L(x.maxDuration), "Spring duration must be 10 seconds or less");
+  let o = 1 - e;
+  o = Y(x.minDamping, x.maxDamping, o), t = Y(x.minDuration, x.maxDuration, /* @__PURE__ */ K(t)), o < 1 ? (i = (l) => {
+    const u = l * o, d = u * t, f = u - n, h = Yt(l, o), y = Math.exp(-d);
+    return je - f / h * y;
+  }, r = (l) => {
+    const d = l * o * t, f = d * n + n, h = Math.pow(o, 2) * Math.pow(l, 2) * t, y = Math.exp(-d), b = Yt(Math.pow(l, 2), o);
+    return (-i(l) + je > 0 ? -1 : 1) * ((f - h) * y) / b;
+  }) : (i = (l) => {
+    const u = Math.exp(-l * t), d = (l - n) * t + 1;
+    return -1e-3 + u * d;
+  }, r = (l) => {
+    const u = Math.exp(-l * t), d = (n - l) * (t * t);
+    return u * d;
+  });
+  const a = 5 / t, c = Ii(i, r, a);
+  if (t = /* @__PURE__ */ L(t), isNaN(c))
+    return {
+      stiffness: x.stiffness,
+      damping: x.damping,
+      duration: t
+    };
+  {
+    const l = Math.pow(c, 2) * s;
+    return {
+      stiffness: l,
+      damping: o * 2 * Math.sqrt(s * l),
+      duration: t
+    };
+  }
+}
+const Ri = 12;
+function Ii(t, e, n) {
+  let s = n;
+  for (let i = 1; i < Ri; i++)
+    s = s - t(s) / e(s);
+  return s;
+}
+function Yt(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const Ei = ["duration", "bounce"], ki = ["stiffness", "damping", "mass"];
+function Ge(t, e) {
+  return e.some((n) => t[n] !== void 0);
+}
+function Ni(t) {
+  let e = {
+    velocity: x.velocity,
+    stiffness: x.stiffness,
+    damping: x.damping,
+    mass: x.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!Ge(t, ki) && Ge(t, Ei))
+    if (t.visualDuration) {
+      const n = t.visualDuration, s = 2 * Math.PI / (n * 1.2), i = s * s, r = 2 * Y(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(i);
+      e = {
+        ...e,
+        mass: x.mass,
+        stiffness: i,
+        damping: r
+      };
+    } else {
+      const n = Di(t);
+      e = {
+        ...e,
+        ...n,
+        mass: x.mass
+      }, e.isResolvedFromDuration = !0;
+    }
+  return e;
+}
+function Ft(t = x.visualDuration, e = x.bounce) {
+  const n = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: e
+  } : t;
+  let { restSpeed: s, restDelta: i } = n;
+  const r = n.keyframes[0], o = n.keyframes[n.keyframes.length - 1], a = { done: !1, value: r }, { stiffness: c, damping: l, mass: u, duration: d, velocity: f, isResolvedFromDuration: h } = Ni({
+    ...n,
+    velocity: -/* @__PURE__ */ K(n.velocity || 0)
+  }), y = f || 0, b = l / (2 * Math.sqrt(c * u)), v = o - r, p = /* @__PURE__ */ K(Math.sqrt(c / u)), S = Math.abs(v) < 5;
+  s || (s = S ? x.restSpeed.granular : x.restSpeed.default), i || (i = S ? x.restDelta.granular : x.restDelta.default);
+  let m;
+  if (b < 1) {
+    const T = Yt(p, b);
+    m = (V) => {
+      const M = Math.exp(-b * p * V);
+      return o - M * ((y + b * p * v) / T * Math.sin(T * V) + v * Math.cos(T * V));
+    };
+  } else if (b === 1)
+    m = (T) => o - Math.exp(-p * T) * (v + (y + p * v) * T);
+  else {
+    const T = p * Math.sqrt(b * b - 1);
+    m = (V) => {
+      const M = Math.exp(-b * p * V), w = Math.min(T * V, 300);
+      return o - M * ((y + b * p * v) * Math.sinh(w) + T * v * Math.cosh(w)) / T;
+    };
+  }
+  const A = {
+    calculatedDuration: h && d || null,
+    next: (T) => {
+      const V = m(T);
+      if (h)
+        a.done = T >= d;
+      else {
+        let M = T === 0 ? y : 0;
+        b < 1 && (M = T === 0 ? /* @__PURE__ */ L(y) : jn(m, T, V));
+        const w = Math.abs(M) <= s, F = Math.abs(o - V) <= i;
+        a.done = w && F;
+      }
+      return a.value = a.done ? o : V, a;
+    },
+    toString: () => {
+      const T = Math.min(be(A), Pt), V = $n((M) => A.next(T * M).value, T, 30);
+      return T + "ms " + V;
+    },
+    toTransition: () => {
+    }
+  };
+  return A;
+}
+Ft.applyToOptions = (t) => {
+  const e = Fi(t, 100, Ft);
+  return t.ease = e.ease, t.duration = /* @__PURE__ */ L(e.duration), t.type = "keyframes", t;
+};
+function Xt({ keyframes: t, velocity: e = 0, power: n = 0.8, timeConstant: s = 325, bounceDamping: i = 10, bounceStiffness: r = 500, modifyTarget: o, min: a, max: c, restDelta: l = 0.5, restSpeed: u }) {
+  const d = t[0], f = {
+    done: !1,
+    value: d
+  }, h = (w) => a !== void 0 && w < a || c !== void 0 && w > c, y = (w) => a === void 0 ? c : c === void 0 || Math.abs(a - w) < Math.abs(c - w) ? a : c;
+  let b = n * e;
+  const v = d + b, p = o === void 0 ? v : o(v);
+  p !== v && (b = p - d);
+  const S = (w) => -b * Math.exp(-w / s), m = (w) => p + S(w), A = (w) => {
+    const F = S(w), D = m(w);
+    f.done = Math.abs(F) <= l, f.value = f.done ? p : D;
+  };
+  let T, V;
+  const M = (w) => {
+    h(f.value) && (T = w, V = Ft({
+      keyframes: [f.value, y(f.value)],
+      velocity: jn(m, w, f.value),
+      // TODO: This should be passing * 1000
+      damping: i,
+      stiffness: r,
+      restDelta: l,
+      restSpeed: u
+    }));
+  };
+  return M(0), {
+    calculatedDuration: null,
+    next: (w) => {
+      let F = !1;
+      return !V && T === void 0 && (F = !0, A(w), M(w)), T !== void 0 && w >= T ? V.next(w - T) : (!F && A(w), f);
+    }
+  };
+}
+function Li(t, e, n) {
+  const s = [], i = n || W.mix || Wn, r = t.length - 1;
+  for (let o = 0; o < r; o++) {
+    let a = i(t[o], t[o + 1]);
+    if (e) {
+      const c = Array.isArray(e) ? e[o] || et : e;
+      a = It(c, a);
+    }
+    s.push(a);
+  }
+  return s;
+}
+function Bi(t, e, { clamp: n = !0, ease: s, mixer: i } = {}) {
+  const r = t.length;
+  if (j(r === e.length, "Both input and output ranges must be the same length"), r === 1)
+    return () => e[0];
+  if (r === 2 && e[0] === e[1])
+    return () => e[1];
+  const o = t[0] === t[1];
+  t[0] > t[r - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const a = Li(e, s, i), c = a.length, l = (u) => {
+    if (o && u < t[0])
+      return e[0];
+    let d = 0;
+    if (c > 1)
+      for (; d < t.length - 2 && !(u < t[d + 1]); d++)
+        ;
+    const f = /* @__PURE__ */ bn(t[d], t[d + 1], u);
+    return a[d](f);
+  };
+  return n ? (u) => l(Y(t[0], t[r - 1], u)) : l;
+}
+function Ki(t, e) {
+  const n = t[t.length - 1];
+  for (let s = 1; s <= e; s++) {
+    const i = /* @__PURE__ */ bn(0, e, s);
+    t.push(Et(n, 1, i));
+  }
+}
+function Wi(t) {
+  const e = [0];
+  return Ki(e, t.length - 1), e;
+}
+function $i(t, e) {
+  return t.map((n) => n * e);
+}
+function ji(t, e) {
+  return t.map(() => e || Fn).splice(0, t.length - 1);
+}
+function q({ duration: t = 300, keyframes: e, times: n, ease: s = "easeInOut" }) {
+  const i = ti(s) ? s.map(Le) : Le(s), r = {
+    done: !1,
+    value: e[0]
+  }, o = $i(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    n && n.length === e.length ? n : Wi(e),
+    t
+  ), a = Bi(o, e, {
+    ease: Array.isArray(i) ? i : ji(e, i)
+  });
+  return {
+    calculatedDuration: t,
+    next: (c) => (r.value = a(c), r.done = c >= t, r)
+  };
+}
+const Gi = (t) => t !== null;
+function Te(t, { repeat: e, repeatType: n = "loop" }, s, i = 1) {
+  const r = t.filter(Gi), a = i < 0 || e && n !== "loop" && e % 2 === 1 ? 0 : r.length - 1;
+  return !a || s === void 0 ? r[a] : s;
+}
+const _i = {
+  decay: Xt,
+  inertia: Xt,
+  tween: q,
+  keyframes: q,
+  spring: Ft
+};
+function Gn(t) {
+  typeof t.type == "string" && (t.type = _i[t.type]);
+}
+class ve {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((e) => {
+      this.resolve = e;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  /**
+   * Allows the animation to be awaited.
+   *
+   * @deprecated Use `finished` instead.
+   */
+  then(e, n) {
+    return this.finished.then(e, n);
+  }
+}
+const Ui = (t) => t / 100;
+class we extends ve {
+  constructor(e) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+      var s, i;
+      const { motionValue: n } = this.options;
+      n && n.updatedAt !== E.now() && this.tick(E.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), (i = (s = this.options).onStop) == null || i.call(s));
+    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: e } = this;
+    Gn(e);
+    const { type: n = q, repeat: s = 0, repeatDelay: i = 0, repeatType: r, velocity: o = 0 } = e;
+    let { keyframes: a } = e;
+    const c = n || q;
+    process.env.NODE_ENV !== "production" && c !== q && j(a.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${a}`), c !== q && typeof a[0] != "number" && (this.mixKeyframes = It(Ui, Wn(a[0], a[1])), a = [0, 100]);
+    const l = c({ ...e, keyframes: a });
+    r === "mirror" && (this.mirroredGenerator = c({
+      ...e,
+      keyframes: [...a].reverse(),
+      velocity: -o
+    })), l.calculatedDuration === null && (l.calculatedDuration = be(l));
+    const { calculatedDuration: u } = l;
+    this.calculatedDuration = u, this.resolvedDuration = u + i, this.totalDuration = this.resolvedDuration * (s + 1) - i, this.generator = l;
+  }
+  updateTime(e) {
+    const n = Math.round(e - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = n;
+  }
+  tick(e, n = !1) {
+    const { generator: s, totalDuration: i, mixKeyframes: r, mirroredGenerator: o, resolvedDuration: a, calculatedDuration: c } = this;
+    if (this.startTime === null)
+      return s.next(0);
+    const { delay: l = 0, keyframes: u, repeat: d, repeatType: f, repeatDelay: h, type: y, onUpdate: b, finalKeyframe: v } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - i / this.speed, this.startTime)), n ? this.currentTime = e : this.updateTime(e);
+    const p = this.currentTime - l * (this.playbackSpeed >= 0 ? 1 : -1), S = this.playbackSpeed >= 0 ? p < 0 : p > i;
+    this.currentTime = Math.max(p, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = i);
+    let m = this.currentTime, A = s;
+    if (d) {
+      const w = Math.min(this.currentTime, i) / a;
+      let F = Math.floor(w), D = w % 1;
+      !D && w >= 1 && (D = 1), D === 1 && F--, F = Math.min(F, d + 1), !!(F % 2) && (f === "reverse" ? (D = 1 - D, h && (D -= h / a)) : f === "mirror" && (A = o)), m = Y(0, 1, D) * a;
+    }
+    const T = S ? { done: !1, value: u[0] } : A.next(m);
+    r && (T.value = r(T.value));
+    let { done: V } = T;
+    !S && c !== null && (V = this.playbackSpeed >= 0 ? this.currentTime >= i : this.currentTime <= 0);
+    const M = this.holdTime === null && (this.state === "finished" || this.state === "running" && V);
+    return M && y !== Xt && (T.value = Te(u, this.options, v, this.speed)), b && b(T.value), M && this.finish(), T;
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(e, n) {
+    return this.finished.then(e, n);
+  }
+  get duration() {
+    return /* @__PURE__ */ K(this.calculatedDuration);
+  }
+  get time() {
+    return /* @__PURE__ */ K(this.currentTime);
+  }
+  set time(e) {
+    var n;
+    e = /* @__PURE__ */ L(e), this.currentTime = e, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.playbackSpeed), (n = this.driver) == null || n.start(!1);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(e) {
+    this.updateTime(E.now());
+    const n = this.playbackSpeed !== e;
+    this.playbackSpeed = e, n && (this.time = /* @__PURE__ */ K(this.currentTime));
+  }
+  play() {
+    var i, r;
+    if (this.isStopped)
+      return;
+    const { driver: e = Pi, startTime: n } = this.options;
+    this.driver || (this.driver = e((o) => this.tick(o))), (r = (i = this.options).onPlay) == null || r.call(i);
+    const s = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = n ?? s), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(E.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    var e, n;
+    this.notifyFinished(), this.teardown(), this.state = "finished", (n = (e = this.options).onComplete) == null || n.call(e);
+  }
+  cancel() {
+    var e, n;
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), (n = (e = this.options).onCancel) == null || n.call(e);
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(e) {
+    return this.startTime = 0, this.tick(e, !0);
+  }
+  attachTimeline(e) {
+    var n;
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), (n = this.driver) == null || n.stop(), e.observe(this);
+  }
+}
+function Hi(t) {
+  for (let e = 1; e < t.length; e++)
+    t[e] ?? (t[e] = t[e - 1]);
+}
+const U = (t) => t * 180 / Math.PI, qt = (t) => {
+  const e = U(Math.atan2(t[1], t[0]));
+  return Zt(e);
+}, zi = {
+  x: 4,
+  y: 5,
+  translateX: 4,
+  translateY: 5,
+  scaleX: 0,
+  scaleY: 3,
+  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
+  rotate: qt,
+  rotateZ: qt,
+  skewX: (t) => U(Math.atan(t[1])),
+  skewY: (t) => U(Math.atan(t[2])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
+}, Zt = (t) => (t = t % 360, t < 0 && (t += 360), t), _e = qt, Ue = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), He = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), Yi = {
+  x: 12,
+  y: 13,
+  z: 14,
+  translateX: 12,
+  translateY: 13,
+  translateZ: 14,
+  scaleX: Ue,
+  scaleY: He,
+  scale: (t) => (Ue(t) + He(t)) / 2,
+  rotateX: (t) => Zt(U(Math.atan2(t[6], t[5]))),
+  rotateY: (t) => Zt(U(Math.atan2(-t[2], t[0]))),
+  rotateZ: _e,
+  rotate: _e,
+  skewX: (t) => U(Math.atan(t[4])),
+  skewY: (t) => U(Math.atan(t[1])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
+};
+function Jt(t) {
+  return t.includes("scale") ? 1 : 0;
+}
+function Qt(t, e) {
+  if (!t || t === "none")
+    return Jt(e);
+  const n = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
+  let s, i;
+  if (n)
+    s = Yi, i = n;
+  else {
+    const a = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+    s = zi, i = a;
+  }
+  if (!i)
+    return Jt(e);
+  const r = s[e], o = i[1].split(",").map(qi);
+  return typeof r == "function" ? r(o) : o[r];
+}
+const Xi = (t, e) => {
+  const { transform: n = "none" } = getComputedStyle(t);
+  return Qt(n, e);
+};
+function qi(t) {
+  return parseFloat(t.trim());
+}
+const it = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], rt = new Set(it), ze = (t) => t === nt || t === g, Zi = /* @__PURE__ */ new Set(["x", "y", "z"]), Ji = it.filter((t) => !Zi.has(t));
+function Qi(t) {
+  const e = [];
+  return Ji.forEach((n) => {
+    const s = t.getValue(n);
+    s !== void 0 && (e.push([n, s.get()]), s.set(n.startsWith("scale") ? 1 : 0));
+  }), e;
+}
+const H = {
+  // Dimensions
+  width: ({ x: t }, { paddingLeft: e = "0", paddingRight: n = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(n),
+  height: ({ y: t }, { paddingTop: e = "0", paddingBottom: n = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(n),
+  top: (t, { top: e }) => parseFloat(e),
+  left: (t, { left: e }) => parseFloat(e),
+  bottom: ({ y: t }, { top: e }) => parseFloat(e) + (t.max - t.min),
+  right: ({ x: t }, { left: e }) => parseFloat(e) + (t.max - t.min),
+  // Transform
+  x: (t, { transform: e }) => Qt(e, "x"),
+  y: (t, { transform: e }) => Qt(e, "y")
+};
+H.translateX = H.x;
+H.translateY = H.y;
+const z = /* @__PURE__ */ new Set();
+let te = !1, ee = !1, ne = !1;
+function _n() {
+  if (ee) {
+    const t = Array.from(z).filter((s) => s.needsMeasurement), e = new Set(t.map((s) => s.element)), n = /* @__PURE__ */ new Map();
+    e.forEach((s) => {
+      const i = Qi(s);
+      i.length && (n.set(s, i), s.render());
+    }), t.forEach((s) => s.measureInitialState()), e.forEach((s) => {
+      s.render();
+      const i = n.get(s);
+      i && i.forEach(([r, o]) => {
+        var a;
+        (a = s.getValue(r)) == null || a.set(o);
+      });
+    }), t.forEach((s) => s.measureEndState()), t.forEach((s) => {
+      s.suspendedScrollY !== void 0 && window.scrollTo(0, s.suspendedScrollY);
+    });
+  }
+  ee = !1, te = !1, z.forEach((t) => t.complete(ne)), z.clear();
+}
+function Un() {
+  z.forEach((t) => {
+    t.readKeyframes(), t.needsMeasurement && (ee = !0);
+  });
+}
+function tr() {
+  ne = !0, Un(), _n(), ne = !1;
+}
+class Se {
+  constructor(e, n, s, i, r, o = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...e], this.onComplete = n, this.name = s, this.motionValue = i, this.element = r, this.isAsync = o;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (z.add(this), te || (te = !0, N.read(Un), N.resolveKeyframes(_n))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, name: n, element: s, motionValue: i } = this;
+    if (e[0] === null) {
+      const r = i == null ? void 0 : i.get(), o = e[e.length - 1];
+      if (r !== void 0)
+        e[0] = r;
+      else if (s && n) {
+        const a = s.readValue(n, o);
+        a != null && (e[0] = a);
+      }
+      e[0] === void 0 && (e[0] = o), i && r === void 0 && i.set(e[0]);
+    }
+    Hi(e);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(e = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, e), z.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (z.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}
+const er = (t) => t.startsWith("--");
+function nr(t, e, n) {
+  er(e) ? t.style.setProperty(e, n) : t.style[e] = n;
+}
+const sr = /* @__PURE__ */ fe(() => window.ScrollTimeline !== void 0), ir = {};
+function rr(t, e) {
+  const n = /* @__PURE__ */ fe(t);
+  return () => ir[e] ?? n();
+}
+const Hn = /* @__PURE__ */ rr(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing"), ut = ([t, e, n, s]) => `cubic-bezier(${t}, ${e}, ${n}, ${s})`, Ye = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ ut([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ ut([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ ut([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ ut([0.33, 1.53, 0.69, 0.99])
+};
+function zn(t, e) {
+  if (t)
+    return typeof t == "function" ? Hn() ? $n(t, e) : "ease-out" : On(t) ? ut(t) : Array.isArray(t) ? t.map((n) => zn(n, e) || Ye.easeOut) : Ye[t];
+}
+function or(t, e, n, { delay: s = 0, duration: i = 300, repeat: r = 0, repeatType: o = "loop", ease: a = "easeOut", times: c } = {}, l = void 0) {
+  const u = {
+    [e]: n
+  };
+  c && (u.offset = c);
+  const d = zn(a, i);
+  Array.isArray(d) && (u.easing = d);
+  const f = {
+    delay: s,
+    duration: i,
+    easing: Array.isArray(d) ? "linear" : d,
+    fill: "both",
+    iterations: r + 1,
+    direction: o === "reverse" ? "alternate" : "normal"
+  };
+  return l && (f.pseudoElement = l), t.animate(u, f);
+}
+function Yn(t) {
+  return typeof t == "function" && "applyToOptions" in t;
+}
+function ar({ type: t, ...e }) {
+  return Yn(t) && Hn() ? t.applyToOptions(e) : (e.duration ?? (e.duration = 300), e.ease ?? (e.ease = "easeOut"), e);
+}
+class ur extends ve {
+  constructor(e) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, !e)
+      return;
+    const { element: n, name: s, keyframes: i, pseudoElement: r, allowFlatten: o = !1, finalKeyframe: a, onComplete: c } = e;
+    this.isPseudoElement = !!r, this.allowFlatten = o, this.options = e, j(typeof e.type != "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "motion"?`);
+    const l = ar(e);
+    this.animation = or(n, s, i, l, r), l.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !r) {
+        const u = Te(i, this.options, a, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(u) : nr(n, s, u), this.animation.cancel();
+      }
+      c == null || c(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    var e, n;
+    (n = (e = this.animation).finish) == null || n.call(e);
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: e } = this;
+    e === "idle" || e === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * In this method, we commit styles back to the DOM before cancelling
+   * the animation.
+   *
+   * This is designed to be overridden by NativeAnimationExtended, which
+   * will create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to also correctly calculate velocity for any subsequent animation
+   * while deferring the commit until the next animation frame.
+   */
+  commitStyles() {
+    var e, n;
+    this.isPseudoElement || (n = (e = this.animation).commitStyles) == null || n.call(e);
+  }
+  get duration() {
+    var n, s;
+    const e = ((s = (n = this.animation.effect) == null ? void 0 : n.getComputedTiming) == null ? void 0 : s.call(n).duration) || 0;
+    return /* @__PURE__ */ K(Number(e));
+  }
+  get time() {
+    return /* @__PURE__ */ K(Number(this.animation.currentTime) || 0);
+  }
+  set time(e) {
+    this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ L(e);
+  }
+  /**
+   * The playback speed of the animation.
+   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+   */
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(e) {
+    e < 0 && (this.finishedTime = null), this.animation.playbackRate = e;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return Number(this.animation.startTime);
+  }
+  set startTime(e) {
+    this.animation.startTime = e;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: e, observe: n }) {
+    var s;
+    return this.allowFlatten && ((s = this.animation.effect) == null || s.updateTiming({ easing: "linear" })), this.animation.onfinish = null, e && sr() ? (this.animation.timeline = e, et) : n(this);
+  }
+}
+const Xn = {
+  anticipate: Cn,
+  backInOut: Mn,
+  circInOut: Pn
+};
+function cr(t) {
+  return t in Xn;
+}
+function lr(t) {
+  typeof t.ease == "string" && cr(t.ease) && (t.ease = Xn[t.ease]);
+}
+const Xe = 10;
+class fr extends ur {
+  constructor(e) {
+    lr(e), Gn(e), super(e), e.startTime && (this.startTime = e.startTime), this.options = e;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read commited styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
+   */
+  updateMotionValue(e) {
+    const { motionValue: n, onUpdate: s, onComplete: i, element: r, ...o } = this.options;
+    if (!n)
+      return;
+    if (e !== void 0) {
+      n.set(e);
+      return;
+    }
+    const a = new we({
+      ...o,
+      autoplay: !1
+    }), c = /* @__PURE__ */ L(this.finishedTime ?? this.time);
+    n.setWithVelocity(a.sample(c - Xe).value, a.sample(c).value, Xe), a.stop();
+  }
+}
+const qe = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(st.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url("));
+function dr(t) {
+  const e = t[0];
+  if (t.length === 1)
+    return !0;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== e)
+      return !0;
+}
+function hr(t, e, n, s) {
+  const i = t[0];
+  if (i === null)
+    return !1;
+  if (e === "display" || e === "visibility")
+    return !0;
+  const r = t[t.length - 1], o = qe(i, e), a = qe(r, e);
+  return tt(o === a, `You are trying to animate ${e} from "${i}" to "${r}". ${i} is not an animatable value - to enable this animation set ${i} to a value animatable to ${r} via the \`style\` property.`), !o || !a ? !1 : dr(t) || (n === "spring" || Yn(n)) && s;
+}
+function qn(t) {
+  return Hs(t) && "offsetHeight" in t;
+}
+const pr = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Could be re-enabled now we have support for linear() easing
+  // "background-color"
+]), mr = /* @__PURE__ */ fe(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function gr(t) {
+  var l;
+  const { motionValue: e, name: n, repeatDelay: s, repeatType: i, damping: r, type: o } = t;
+  if (!qn((l = e == null ? void 0 : e.owner) == null ? void 0 : l.current))
+    return !1;
+  const { onUpdate: a, transformTemplate: c } = e.owner.getProps();
+  return mr() && n && pr.has(n) && (n !== "transform" || !c) && /**
+   * If we're outputting values to onUpdate then we can't use WAAPI as there's
+   * no way to read the value from WAAPI every frame.
+   */
+  !a && !s && i !== "mirror" && r !== 0 && o !== "inertia";
+}
+const yr = 40;
+class br extends ve {
+  constructor({ autoplay: e = !0, delay: n = 0, type: s = "keyframes", repeat: i = 0, repeatDelay: r = 0, repeatType: o = "loop", keyframes: a, name: c, motionValue: l, element: u, ...d }) {
+    var y;
+    super(), this.stop = () => {
+      var b, v;
+      this._animation && (this._animation.stop(), (b = this.stopTimeline) == null || b.call(this)), (v = this.keyframeResolver) == null || v.cancel();
+    }, this.createdAt = E.now();
+    const f = {
+      autoplay: e,
+      delay: n,
+      type: s,
+      repeat: i,
+      repeatDelay: r,
+      repeatType: o,
+      name: c,
+      motionValue: l,
+      element: u,
+      ...d
+    }, h = (u == null ? void 0 : u.KeyframeResolver) || Se;
+    this.keyframeResolver = new h(a, (b, v, p) => this.onKeyframesResolved(b, v, f, !p), c, l, u), (y = this.keyframeResolver) == null || y.scheduleResolve();
+  }
+  onKeyframesResolved(e, n, s, i) {
+    this.keyframeResolver = void 0;
+    const { name: r, type: o, velocity: a, delay: c, isHandoff: l, onUpdate: u } = s;
+    this.resolvedAt = E.now(), hr(e, r, o, a) || ((W.instantAnimations || !c) && (u == null || u(Te(e, s, n))), e[0] = e[e.length - 1], s.duration = 0, s.repeat = 0);
+    const f = {
+      startTime: i ? this.resolvedAt ? this.resolvedAt - this.createdAt > yr ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: n,
+      ...s,
+      keyframes: e
+    }, h = !l && gr(f) ? new fr({
+      ...f,
+      element: f.motionValue.owner.current
+    }) : new we(f);
+    h.finished.then(() => this.notifyFinished()).catch(et), this.pendingTimeline && (this.stopTimeline = h.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = h;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(e, n) {
+    return this.finished.finally(e).then(() => {
+    });
+  }
+  get animation() {
+    var e;
+    return this._animation || ((e = this.keyframeResolver) == null || e.resume(), tr()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(e) {
+    this.animation.time = e;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(e) {
+    this.animation.speed = e;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(e) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(e) : this.pendingTimeline = e, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    var e;
+    this._animation && this.animation.cancel(), (e = this.keyframeResolver) == null || e.cancel();
+  }
+}
+const Tr = (
+  // eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
+  /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
+);
+function vr(t) {
+  const e = Tr.exec(t);
+  if (!e)
+    return [,];
+  const [, n, s, i] = e;
+  return [`--${n ?? s}`, i];
+}
+const wr = 4;
+function Zn(t, e, n = 1) {
+  j(n <= wr, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`);
+  const [s, i] = vr(t);
+  if (!s)
+    return;
+  const r = window.getComputedStyle(e).getPropertyValue(s);
+  if (r) {
+    const o = r.trim();
+    return gn(o) ? parseFloat(o) : o;
+  }
+  return pe(i) ? Zn(i, e, n + 1) : i;
+}
+function Jn(t, e) {
+  return (t == null ? void 0 : t[e]) ?? (t == null ? void 0 : t.default) ?? t;
+}
+const Qn = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...it
+]), Sr = {
+  test: (t) => t === "auto",
+  parse: (t) => t
+}, ts = (t) => (e) => e.test(t), es = [nt, g, Z, $, di, fi, Sr], Ze = (t) => es.find(ts(t));
+function Vr(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || yn(t) : !0;
+}
+const Ar = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function xr(t) {
+  const [e, n] = t.slice(0, -1).split("(");
+  if (e === "drop-shadow")
+    return t;
+  const [s] = n.match(me) || [];
+  if (!s)
+    return t;
+  const i = n.replace(s, "");
+  let r = Ar.has(e) ? 1 : 0;
+  return s !== n && (r *= 100), e + "(" + r + i + ")";
+}
+const Mr = /\b([a-z-]*)\(.*?\)/gu, se = {
+  ...st,
+  getAnimatableNone: (t) => {
+    const e = t.match(Mr);
+    return e ? e.map(xr).join(" ") : t;
+  }
+}, Je = {
+  ...nt,
+  transform: Math.round
+}, Cr = {
+  rotate: $,
+  rotateX: $,
+  rotateY: $,
+  rotateZ: $,
+  scale: Vt,
+  scaleX: Vt,
+  scaleY: Vt,
+  scaleZ: Vt,
+  skew: $,
+  skewX: $,
+  skewY: $,
+  distance: g,
+  translateX: g,
+  translateY: g,
+  translateZ: g,
+  x: g,
+  y: g,
+  z: g,
+  perspective: g,
+  transformPerspective: g,
+  opacity: dt,
+  originX: Be,
+  originY: Be,
+  originZ: g
+}, Ve = {
+  // Border props
+  borderWidth: g,
+  borderTopWidth: g,
+  borderRightWidth: g,
+  borderBottomWidth: g,
+  borderLeftWidth: g,
+  borderRadius: g,
+  radius: g,
+  borderTopLeftRadius: g,
+  borderTopRightRadius: g,
+  borderBottomRightRadius: g,
+  borderBottomLeftRadius: g,
+  // Positioning props
+  width: g,
+  maxWidth: g,
+  height: g,
+  maxHeight: g,
+  top: g,
+  right: g,
+  bottom: g,
+  left: g,
+  // Spacing props
+  padding: g,
+  paddingTop: g,
+  paddingRight: g,
+  paddingBottom: g,
+  paddingLeft: g,
+  margin: g,
+  marginTop: g,
+  marginRight: g,
+  marginBottom: g,
+  marginLeft: g,
+  // Misc
+  backgroundPositionX: g,
+  backgroundPositionY: g,
+  ...Cr,
+  zIndex: Je,
+  // SVG
+  fillOpacity: dt,
+  strokeOpacity: dt,
+  numOctaves: Je
+}, Pr = {
+  ...Ve,
+  // Color props
+  color: C,
+  backgroundColor: C,
+  outlineColor: C,
+  fill: C,
+  stroke: C,
+  // Border props
+  borderColor: C,
+  borderTopColor: C,
+  borderRightColor: C,
+  borderBottomColor: C,
+  borderLeftColor: C,
+  filter: se,
+  WebkitFilter: se
+}, ns = (t) => Pr[t];
+function ss(t, e) {
+  let n = ns(t);
+  return n !== se && (n = st), n.getAnimatableNone ? n.getAnimatableNone(e) : void 0;
+}
+const Fr = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function Or(t, e, n) {
+  let s = 0, i;
+  for (; s < t.length && !i; ) {
+    const r = t[s];
+    typeof r == "string" && !Fr.has(r) && ht(r).values.length && (i = t[s]), s++;
+  }
+  if (i && n)
+    for (const r of e)
+      t[r] = ss(n, i);
+}
+class Dr extends Se {
+  constructor(e, n, s, i, r) {
+    super(e, n, s, i, r, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: n, name: s } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let c = 0; c < e.length; c++) {
+      let l = e[c];
+      if (typeof l == "string" && (l = l.trim(), pe(l))) {
+        const u = Zn(l, n.current);
+        u !== void 0 && (e[c] = u), c === e.length - 1 && (this.finalKeyframe = l);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !Qn.has(s) || e.length !== 2)
+      return;
+    const [i, r] = e, o = Ze(i), a = Ze(r);
+    if (o !== a)
+      if (ze(o) && ze(a))
+        for (let c = 0; c < e.length; c++) {
+          const l = e[c];
+          typeof l == "string" && (e[c] = parseFloat(l));
+        }
+      else H[s] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, s = [];
+    for (let i = 0; i < e.length; i++)
+      (e[i] === null || Vr(e[i])) && s.push(i);
+    s.length && Or(e, s, n);
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: n, name: s } = this;
+    if (!e || !e.current)
+      return;
+    s === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = H[s](e.measureViewportBox(), window.getComputedStyle(e.current)), n[0] = this.measuredOrigin;
+    const i = n[n.length - 1];
+    i !== void 0 && e.getValue(s, i).jump(i, !1);
+  }
+  measureEndState() {
+    var a;
+    const { element: e, name: n, unresolvedKeyframes: s } = this;
+    if (!e || !e.current)
+      return;
+    const i = e.getValue(n);
+    i && i.jump(this.measuredOrigin, !1);
+    const r = s.length - 1, o = s[r];
+    s[r] = H[n](e.measureViewportBox(), window.getComputedStyle(e.current)), o !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = o), (a = this.removedTransforms) != null && a.length && this.removedTransforms.forEach(([c, l]) => {
+      e.getValue(c).set(l);
+    }), this.resolveNoneKeyframes();
+  }
+}
+function Rr(t, e, n) {
+  if (t instanceof EventTarget)
+    return [t];
+  if (typeof t == "string") {
+    const i = document.querySelectorAll(t);
+    return i ? Array.from(i) : [];
+  }
+  return Array.from(t);
+}
+const is = (t, e) => e && typeof t == "number" ? e.transform(t) : t, Qe = 30, Ir = (t) => !isNaN(parseFloat(t));
+class Er {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(e, n = {}) {
+    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s, i = !0) => {
+      var o, a;
+      const r = E.now();
+      if (this.updatedAt !== r && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && ((o = this.events.change) == null || o.notify(this.current), this.dependents))
+        for (const c of this.dependents)
+          c.dirty();
+      i && ((a = this.events.renderRequest) == null || a.notify(this.current));
+    }, this.hasAnimated = !1, this.setCurrent(e), this.owner = n.owner;
+  }
+  setCurrent(e) {
+    this.current = e, this.updatedAt = E.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = Ir(this.current));
+  }
+  setPrevFrameValue(e = this.current) {
+    this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(e) {
+    return process.env.NODE_ENV !== "production" && wn(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", e);
+  }
+  on(e, n) {
+    this.events[e] || (this.events[e] = new Tn());
+    const s = this.events[e].add(n);
+    return e === "change" ? () => {
+      s(), N.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : s;
+  }
+  clearListeners() {
+    for (const e in this.events)
+      this.events[e].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   */
+  attach(e, n) {
+    this.passiveEffect = e, this.stopPassiveEffect = n;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(e, n = !0) {
+    !n || !this.passiveEffect ? this.updateAndNotify(e, n) : this.passiveEffect(e, this.updateAndNotify);
+  }
+  setWithVelocity(e, n, s) {
+    this.set(n), this.prev = void 0, this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt - s;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(e, n = !0) {
+    this.updateAndNotify(e), this.prev = e, this.prevUpdatedAt = this.prevFrameValue = void 0, n && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  dirty() {
+    var e;
+    (e = this.events.change) == null || e.notify(this.current);
+  }
+  addDependent(e) {
+    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(e);
+  }
+  removeDependent(e) {
+    this.dependents && this.dependents.delete(e);
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const e = E.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > Qe)
+      return 0;
+    const n = Math.min(this.updatedAt - this.prevUpdatedAt, Qe);
+    return vn(parseFloat(this.current) - parseFloat(this.prevFrameValue), n);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   */
+  start(e) {
+    return this.stop(), new Promise((n) => {
+      this.hasAnimated = !0, this.animation = e(n), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    var e, n;
+    (e = this.dependents) == null || e.clear(), (n = this.events.destroy) == null || n.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function Ot(t, e) {
+  return new Er(t, e);
+}
+const { schedule: kr, cancel: Ka } = /* @__PURE__ */ Dn(queueMicrotask, !1), Nr = {
+  x: !1,
+  y: !1
+};
+function Lr() {
+  return Nr.y;
+}
+function rs(t, e) {
+  const n = Rr(t), s = new AbortController(), i = {
+    passive: !0,
+    ...e,
+    signal: s.signal
+  };
+  return [n, i, () => s.abort()];
+}
+function tn(t) {
+  return !(t.pointerType === "touch" || Lr());
+}
+function Br(t, e, n = {}) {
+  const [s, i, r] = rs(t, n), o = (a) => {
+    if (!tn(a))
+      return;
+    const { target: c } = a, l = e(c, a);
+    if (typeof l != "function" || !c)
+      return;
+    const u = (d) => {
+      tn(d) && (l(d), c.removeEventListener("pointerleave", u));
+    };
+    c.addEventListener("pointerleave", u, i);
+  };
+  return s.forEach((a) => {
+    a.addEventListener("pointerenter", o, i);
+  }), r;
+}
+const os = (t, e) => e ? t === e ? !0 : os(t, e.parentElement) : !1, Kr = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, Wr = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function $r(t) {
+  return Wr.has(t.tagName) || t.tabIndex !== -1;
+}
+const xt = /* @__PURE__ */ new WeakSet();
+function en(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function jt(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
+}
+const jr = (t, e) => {
+  const n = t.currentTarget;
+  if (!n)
+    return;
+  const s = en(() => {
+    if (xt.has(n))
+      return;
+    jt(n, "down");
+    const i = en(() => {
+      jt(n, "up");
+    }), r = () => jt(n, "cancel");
+    n.addEventListener("keyup", i, e), n.addEventListener("blur", r, e);
+  });
+  n.addEventListener("keydown", s, e), n.addEventListener("blur", () => n.removeEventListener("keydown", s), e);
+};
+function nn(t) {
+  return Kr(t) && !0;
+}
+function Gr(t, e, n = {}) {
+  const [s, i, r] = rs(t, n), o = (a) => {
+    const c = a.currentTarget;
+    if (!nn(a))
+      return;
+    xt.add(c);
+    const l = e(c, a), u = (h, y) => {
+      window.removeEventListener("pointerup", d), window.removeEventListener("pointercancel", f), xt.has(c) && xt.delete(c), nn(h) && typeof l == "function" && l(h, { success: y });
+    }, d = (h) => {
+      u(h, c === window || c === document || n.useGlobalTarget || os(c, h.target));
+    }, f = (h) => {
+      u(h, !1);
+    };
+    window.addEventListener("pointerup", d, i), window.addEventListener("pointercancel", f, i);
+  };
+  return s.forEach((a) => {
+    (n.useGlobalTarget ? window : a).addEventListener("pointerdown", o, i), qn(a) && (a.addEventListener("focus", (l) => jr(l, i)), !$r(a) && !a.hasAttribute("tabindex") && (a.tabIndex = 0));
+  }), r;
+}
+const R = (t) => !!(t && t.getVelocity), _r = [...es, C, st], Ur = (t) => _r.find(ts(t)), as = Q({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+}), Ae = Q({ strict: !1 }), sn = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, J = {};
+for (const t in sn)
+  J[t] = {
+    isEnabled: (e) => sn[t].some((n) => !!e[n])
+  };
+function ie(t) {
+  for (const e in t)
+    J[e] = {
+      ...J[e],
+      ...t[e]
+    };
+}
+function Hr({ children: t, features: e, strict: n = !1 }) {
+  const [, s] = Ns(!Gt(e)), i = ct(void 0);
+  if (!Gt(e)) {
+    const { renderer: r, ...o } = e;
+    i.current = r, ie(o);
+  }
+  return ce(() => {
+    Gt(e) && e().then(({ renderer: r, ...o }) => {
+      ie(o), i.current = r, s(!0);
+    });
+  }, []), I(Ae.Provider, { value: { renderer: i.current, strict: n }, children: t });
+}
+function Gt(t) {
+  return typeof t == "function";
+}
+const zr = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "ignoreStrict",
+  "viewport"
+]);
+function Dt(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || zr.has(t);
+}
+let us = (t) => !Dt(t);
+function Yr(t) {
+  typeof t == "function" && (us = (e) => e.startsWith("on") ? !Dt(e) : t(e));
+}
+try {
+  Yr(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function Xr(t, e, n) {
+  const s = {};
+  for (const i in t)
+    i === "values" && typeof t.values == "object" || (us(i) || n === !0 && Dt(i) || !e && !Dt(i) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && i.startsWith("onDrag")) && (s[i] = t[i]);
+  return s;
+}
+const kt = /* @__PURE__ */ Q({});
+function Nt(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+function pt(t) {
+  return typeof t == "string" || Array.isArray(t);
+}
+const xe = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], Me = ["initial", ...xe];
+function Lt(t) {
+  return Nt(t.animate) || Me.some((e) => pt(t[e]));
+}
+function cs(t) {
+  return !!(Lt(t) || t.variants);
+}
+function qr(t, e) {
+  if (Lt(t)) {
+    const { initial: n, animate: s } = t;
+    return {
+      initial: n === !1 || pt(n) ? n : void 0,
+      animate: pt(s) ? s : void 0
+    };
+  }
+  return t.inherit !== !1 ? e : {};
+}
+function Zr(t) {
+  const { initial: e, animate: n } = qr(t, k(kt));
+  return Rt(() => ({ initial: e, animate: n }), [rn(e), rn(n)]);
+}
+function rn(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+const Jr = Symbol.for("motionComponentSymbol");
+function ls(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+function Qr(t, e, n) {
+  return Ls(
+    (s) => {
+      s && t.onMount && t.onMount(s), e && (s ? e.mount(s) : e.unmount()), n && (typeof n == "function" ? n(s) : ls(n) && (n.current = s));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [e]
+  );
+}
+const Ce = (t) => t.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase(), to = "framerAppearId", fs = "data-" + Ce(to), eo = Q({});
+function no(t, e, n, s, i) {
+  var b, v;
+  const { visualElement: r } = k(kt), o = k(Ae), a = k(mn), c = k(as).reducedMotion, l = ct(null);
+  s = s || o.renderer, !l.current && s && (l.current = s(t, {
+    visualState: e,
+    parent: r,
+    props: n,
+    presenceContext: a,
+    blockInitialAnimation: a ? a.initial === !1 : !1,
+    reducedMotionConfig: c
+  }));
+  const u = l.current, d = k(eo);
+  u && !u.projection && i && (u.type === "html" || u.type === "svg") && so(l.current, n, i, d);
+  const f = ct(!1);
+  Bs(() => {
+    u && f.current && u.update(n, a);
+  });
+  const h = n[fs], y = ct(!!h && !((b = window.MotionHandoffIsComplete) != null && b.call(window, h)) && ((v = window.MotionHasOptimisedAnimation) == null ? void 0 : v.call(window, h)));
+  return Gs(() => {
+    u && (f.current = !0, window.MotionIsMounted = !0, u.updateFeatures(), kr.render(u.render), y.current && u.animationState && u.animationState.animateChanges());
+  }), ce(() => {
+    u && (!y.current && u.animationState && u.animationState.animateChanges(), y.current && (queueMicrotask(() => {
+      var p;
+      (p = window.MotionHandoffMarkAsComplete) == null || p.call(window, h);
+    }), y.current = !1));
+  }), u;
+}
+function so(t, e, n, s) {
+  const { layoutId: i, layout: r, drag: o, dragConstraints: a, layoutScroll: c, layoutRoot: l, layoutCrossfade: u } = e;
+  t.projection = new n(t.latestValues, e["data-framer-portal-id"] ? void 0 : ds(t.parent)), t.projection.setOptions({
+    layoutId: i,
+    layout: r,
+    alwaysMeasureLayout: !!o || a && ls(a),
+    visualElement: t,
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof r == "string" ? r : "both",
+    initialPromotionConfig: s,
+    crossfade: u,
+    layoutScroll: c,
+    layoutRoot: l
+  });
+}
+function ds(t) {
+  if (t)
+    return t.options.allowProjection !== !1 ? t.projection : ds(t.parent);
+}
+function io({ preloadedFeatures: t, createVisualElement: e, useRender: n, useVisualState: s, Component: i }) {
+  t && ie(t);
+  function r(a, c) {
+    let l;
+    const u = {
+      ...k(as),
+      ...a,
+      layoutId: ro(a)
+    }, { isStatic: d } = u, f = Zr(a), h = s(a, d);
+    if (!d && le) {
+      oo(u, t);
+      const y = ao(u);
+      l = y.MeasureLayout, f.visualElement = no(i, h, u, e, y.ProjectionNode);
+    }
+    return hn(kt.Provider, { value: f, children: [l && f.visualElement ? I(l, { visualElement: f.visualElement, ...u }) : null, n(i, a, Qr(h, f.visualElement, c), h, d, f.visualElement)] });
+  }
+  r.displayName = `motion.${typeof i == "string" ? i : `create(${i.displayName ?? i.name ?? ""})`}`;
+  const o = Ks(r);
+  return o[Jr] = i, o;
+}
+function ro({ layoutId: t }) {
+  const e = k($s).id;
+  return e && t !== void 0 ? e + "-" + t : t;
+}
+function oo(t, e) {
+  const n = k(Ae).strict;
+  if (process.env.NODE_ENV !== "production" && e && n) {
+    const s = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? tt(!1, s) : j(!1, s);
+  }
+}
+function ao(t) {
+  const { drag: e, layout: n } = J;
+  if (!e && !n)
+    return {};
+  const s = { ...e, ...n };
+  return {
+    MeasureLayout: e != null && e.isEnabled(t) || n != null && n.isEnabled(t) ? s.MeasureLayout : void 0,
+    ProjectionNode: s.ProjectionNode
+  };
+}
+const uo = {};
+function hs(t, { layout: e, layoutId: n }) {
+  return rt.has(t) || t.startsWith("origin") || (e || n !== void 0) && (!!uo[t] || t === "opacity");
+}
+const co = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, lo = it.length;
+function fo(t, e, n) {
+  let s = "", i = !0;
+  for (let r = 0; r < lo; r++) {
+    const o = it[r], a = t[o];
+    if (a === void 0)
+      continue;
+    let c = !0;
+    if (typeof a == "number" ? c = a === (o.startsWith("scale") ? 1 : 0) : c = parseFloat(a) === 0, !c || n) {
+      const l = is(a, Ve[o]);
+      if (!c) {
+        i = !1;
+        const u = co[o] || o;
+        s += `${u}(${l}) `;
+      }
+      n && (e[o] = l);
+    }
+  }
+  return s = s.trim(), n ? s = n(e, i ? "" : s) : i && (s = "none"), s;
+}
+function Pe(t, e, n) {
+  const { style: s, vars: i, transformOrigin: r } = t;
+  let o = !1, a = !1;
+  for (const c in e) {
+    const l = e[c];
+    if (rt.has(c)) {
+      o = !0;
+      continue;
+    } else if (In(c)) {
+      i[c] = l;
+      continue;
+    } else {
+      const u = is(l, Ve[c]);
+      c.startsWith("origin") ? (a = !0, r[c] = u) : s[c] = u;
+    }
+  }
+  if (e.transform || (o || n ? s.transform = fo(e, t.transform, n) : s.transform && (s.transform = "none")), a) {
+    const { originX: c = "50%", originY: l = "50%", originZ: u = 0 } = r;
+    s.transformOrigin = `${c} ${l} ${u}`;
+  }
+}
+const Fe = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+function ps(t, e, n) {
+  for (const s in e)
+    !R(e[s]) && !hs(s, n) && (t[s] = e[s]);
+}
+function ho({ transformTemplate: t }, e) {
+  return Rt(() => {
+    const n = Fe();
+    return Pe(n, e, t), Object.assign({}, n.vars, n.style);
+  }, [e]);
+}
+function po(t, e) {
+  const n = t.style || {}, s = {};
+  return ps(s, n, t), Object.assign(s, ho(t, e)), s;
+}
+function mo(t, e) {
+  const n = {}, s = po(t, e);
+  return t.drag && t.dragListener !== !1 && (n.draggable = !1, s.userSelect = s.WebkitUserSelect = s.WebkitTouchCallout = "none", s.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (n.tabIndex = 0), n.style = s, n;
+}
+const go = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, yo = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function bo(t, e, n = 1, s = 0, i = !0) {
+  t.pathLength = 1;
+  const r = i ? go : yo;
+  t[r.offset] = g.transform(-s);
+  const o = g.transform(e), a = g.transform(n);
+  t[r.array] = `${o} ${a}`;
+}
+function ms(t, {
+  attrX: e,
+  attrY: n,
+  attrScale: s,
+  pathLength: i,
+  pathSpacing: r = 1,
+  pathOffset: o = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...a
+}, c, l, u) {
+  if (Pe(t, a, l), c) {
+    t.style.viewBox && (t.attrs.viewBox = t.style.viewBox);
+    return;
+  }
+  t.attrs = t.style, t.style = {};
+  const { attrs: d, style: f } = t;
+  d.transform && (f.transform = d.transform, delete d.transform), (f.transform || d.transformOrigin) && (f.transformOrigin = d.transformOrigin ?? "50% 50%", delete d.transformOrigin), f.transform && (f.transformBox = (u == null ? void 0 : u.transformBox) ?? "fill-box", delete d.transformBox), e !== void 0 && (d.x = e), n !== void 0 && (d.y = n), s !== void 0 && (d.scale = s), i !== void 0 && bo(d, i, r, o, !1);
+}
+const gs = () => ({
+  ...Fe(),
+  attrs: {}
+}), ys = (t) => typeof t == "string" && t.toLowerCase() === "svg";
+function To(t, e, n, s) {
+  const i = Rt(() => {
+    const r = gs();
+    return ms(r, e, ys(s), t.transformTemplate, t.style), {
+      ...r.attrs,
+      style: { ...r.style }
+    };
+  }, [e]);
+  if (t.style) {
+    const r = {};
+    ps(r, t.style, t), i.style = { ...r, ...i.style };
+  }
+  return i;
+}
+const vo = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+function Oe(t) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof t != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    t.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(vo.indexOf(t) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(t))
+    )
+  );
+}
+function wo(t = !1) {
+  return (n, s, i, { latestValues: r }, o) => {
+    const c = (Oe(n) ? To : mo)(s, r, o, n), l = Xr(s, typeof n == "string", t), u = n !== pn ? { ...l, ...c, ref: i } : {}, { children: d } = s, f = Rt(() => R(d) ? d.get() : d, [d]);
+    return Ws(n, {
+      ...u,
+      children: f
+    });
+  };
+}
+function on(t) {
+  const e = [{}, {}];
+  return t == null || t.values.forEach((n, s) => {
+    e[0][s] = n.get(), e[1][s] = n.getVelocity();
+  }), e;
+}
+function De(t, e, n, s) {
+  if (typeof e == "function") {
+    const [i, r] = on(s);
+    e = e(n !== void 0 ? n : t.custom, i, r);
+  }
+  if (typeof e == "string" && (e = t.variants && t.variants[e]), typeof e == "function") {
+    const [i, r] = on(s);
+    e = e(n !== void 0 ? n : t.custom, i, r);
+  }
+  return e;
+}
+function So(t) {
+  return R(t) ? t.get() : t;
+}
+function Vo({ scrapeMotionValuesFromProps: t, createRenderState: e }, n, s, i) {
+  return {
+    latestValues: Ao(n, s, i, t),
+    renderState: e()
+  };
+}
+const bs = (t) => (e, n) => {
+  const s = k(kt), i = k(mn), r = () => Vo(t, e, s, i);
+  return n ? r() : js(r);
+};
+function Ao(t, e, n, s) {
+  const i = {}, r = s(t, {});
+  for (const f in r)
+    i[f] = So(r[f]);
+  let { initial: o, animate: a } = t;
+  const c = Lt(t), l = cs(t);
+  e && l && !c && t.inherit !== !1 && (o === void 0 && (o = e.initial), a === void 0 && (a = e.animate));
+  let u = n ? n.initial === !1 : !1;
+  u = u || o === !1;
+  const d = u ? a : o;
+  if (d && typeof d != "boolean" && !Nt(d)) {
+    const f = Array.isArray(d) ? d : [d];
+    for (let h = 0; h < f.length; h++) {
+      const y = De(t, f[h]);
+      if (y) {
+        const { transitionEnd: b, transition: v, ...p } = y;
+        for (const S in p) {
+          let m = p[S];
+          if (Array.isArray(m)) {
+            const A = u ? m.length - 1 : 0;
+            m = m[A];
+          }
+          m !== null && (i[S] = m);
+        }
+        for (const S in b)
+          i[S] = b[S];
+      }
+    }
+  }
+  return i;
+}
+function Re(t, e, n) {
+  var r;
+  const { style: s } = t, i = {};
+  for (const o in s)
+    (R(s[o]) || e.style && R(e.style[o]) || hs(o, t) || ((r = n == null ? void 0 : n.getValue(o)) == null ? void 0 : r.liveStyle) !== void 0) && (i[o] = s[o]);
+  return i;
+}
+const xo = {
+  useVisualState: bs({
+    scrapeMotionValuesFromProps: Re,
+    createRenderState: Fe
+  })
+};
+function Ts(t, e, n) {
+  const s = Re(t, e, n);
+  for (const i in t)
+    if (R(t[i]) || R(e[i])) {
+      const r = it.indexOf(i) !== -1 ? "attr" + i.charAt(0).toUpperCase() + i.substring(1) : i;
+      s[r] = t[i];
+    }
+  return s;
+}
+const Mo = {
+  useVisualState: bs({
+    scrapeMotionValuesFromProps: Ts,
+    createRenderState: gs
+  })
+};
+function Co(t, e) {
+  return function(s, { forwardMotionProps: i } = { forwardMotionProps: !1 }) {
+    const o = {
+      ...Oe(s) ? Mo : xo,
+      preloadedFeatures: t,
+      useRender: wo(i),
+      createVisualElement: e,
+      Component: s
+    };
+    return io(o);
+  };
+}
+const Po = /* @__PURE__ */ Co();
+function mt(t, e, n) {
+  const s = t.getProps();
+  return De(s, e, n !== void 0 ? n : s.custom, t);
+}
+const re = (t) => Array.isArray(t);
+function Fo(t, e, n) {
+  t.hasValue(e) ? t.getValue(e).set(n) : t.addValue(e, Ot(n));
+}
+function Oo(t) {
+  return re(t) ? t[t.length - 1] || 0 : t;
+}
+function Do(t, e) {
+  const n = mt(t, e);
+  let { transitionEnd: s = {}, transition: i = {}, ...r } = n || {};
+  r = { ...r, ...s };
+  for (const o in r) {
+    const a = Oo(r[o]);
+    Fo(t, o, a);
+  }
+}
+function Ro(t) {
+  return !!(R(t) && t.add);
+}
+function Io(t, e) {
+  const n = t.getValue("willChange");
+  if (Ro(n))
+    return n.add(e);
+  if (!n && W.WillChange) {
+    const s = new W.WillChange("auto");
+    t.addValue("willChange", s), s.add(e);
+  }
+}
+function Eo(t) {
+  return t.props[fs];
+}
+const ko = (t) => t !== null;
+function No(t, { repeat: e, repeatType: n = "loop" }, s) {
+  const i = t.filter(ko), r = e && n !== "loop" && e % 2 === 1 ? 0 : i.length - 1;
+  return i[r];
+}
+const Lo = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, Bo = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), Ko = {
+  type: "keyframes",
+  duration: 0.8
+}, Wo = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, $o = (t, { keyframes: e }) => e.length > 2 ? Ko : rt.has(t) ? t.startsWith("scale") ? Bo(e[1]) : Lo : Wo;
+function jo({ when: t, delay: e, delayChildren: n, staggerChildren: s, staggerDirection: i, repeat: r, repeatType: o, repeatDelay: a, from: c, elapsed: l, ...u }) {
+  return !!Object.keys(u).length;
+}
+const Go = (t, e, n, s = {}, i, r) => (o) => {
+  const a = Jn(s, t) || {}, c = a.delay || s.delay || 0;
+  let { elapsed: l = 0 } = s;
+  l = l - /* @__PURE__ */ L(c);
+  const u = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...a,
+    delay: -l,
+    onUpdate: (f) => {
+      e.set(f), a.onUpdate && a.onUpdate(f);
+    },
+    onComplete: () => {
+      o(), a.onComplete && a.onComplete();
+    },
+    name: t,
+    motionValue: e,
+    element: r ? void 0 : i
+  };
+  jo(a) || Object.assign(u, $o(t, u)), u.duration && (u.duration = /* @__PURE__ */ L(u.duration)), u.repeatDelay && (u.repeatDelay = /* @__PURE__ */ L(u.repeatDelay)), u.from !== void 0 && (u.keyframes[0] = u.from);
+  let d = !1;
+  if ((u.type === !1 || u.duration === 0 && !u.repeatDelay) && (u.duration = 0, u.delay === 0 && (d = !0)), (W.instantAnimations || W.skipAnimations) && (d = !0, u.duration = 0, u.delay = 0), u.allowFlatten = !a.type && !a.ease, d && !r && e.get() !== void 0) {
+    const f = No(u.keyframes, a);
+    if (f !== void 0) {
+      N.update(() => {
+        u.onUpdate(f), u.onComplete();
+      });
+      return;
+    }
+  }
+  return a.isSync ? new we(u) : new br(u);
+};
+function _o({ protectedKeys: t, needsAnimating: e }, n) {
+  const s = t.hasOwnProperty(n) && e[n] !== !0;
+  return e[n] = !1, s;
+}
+function vs(t, e, { delay: n = 0, transitionOverride: s, type: i } = {}) {
+  let { transition: r = t.getDefaultTransition(), transitionEnd: o, ...a } = e;
+  s && (r = s);
+  const c = [], l = i && t.animationState && t.animationState.getState()[i];
+  for (const u in a) {
+    const d = t.getValue(u, t.latestValues[u] ?? null), f = a[u];
+    if (f === void 0 || l && _o(l, u))
+      continue;
+    const h = {
+      delay: n,
+      ...Jn(r || {}, u)
+    }, y = d.get();
+    if (y !== void 0 && !d.isAnimating && !Array.isArray(f) && f === y && !h.velocity)
+      continue;
+    let b = !1;
+    if (window.MotionHandoffAnimation) {
+      const p = Eo(t);
+      if (p) {
+        const S = window.MotionHandoffAnimation(p, u, N);
+        S !== null && (h.startTime = S, b = !0);
+      }
+    }
+    Io(t, u), d.start(Go(u, d, f, t.shouldReduceMotion && Qn.has(u) ? { type: !1 } : h, t, b));
+    const v = d.animation;
+    v && c.push(v);
+  }
+  return o && Promise.all(c).then(() => {
+    N.update(() => {
+      o && Do(t, o);
+    });
+  }), c;
+}
+function oe(t, e, n = {}) {
+  var c;
+  const s = mt(t, e, n.type === "exit" ? (c = t.presenceContext) == null ? void 0 : c.custom : void 0);
+  let { transition: i = t.getDefaultTransition() || {} } = s || {};
+  n.transitionOverride && (i = n.transitionOverride);
+  const r = s ? () => Promise.all(vs(t, s, n)) : () => Promise.resolve(), o = t.variantChildren && t.variantChildren.size ? (l = 0) => {
+    const { delayChildren: u = 0, staggerChildren: d, staggerDirection: f } = i;
+    return Uo(t, e, l, u, d, f, n);
+  } : () => Promise.resolve(), { when: a } = i;
+  if (a) {
+    const [l, u] = a === "beforeChildren" ? [r, o] : [o, r];
+    return l().then(() => u());
+  } else
+    return Promise.all([r(), o(n.delay)]);
+}
+function Uo(t, e, n = 0, s = 0, i = 0, r = 1, o) {
+  const a = [], c = t.variantChildren.size, l = (c - 1) * i, u = typeof s == "function", d = u ? (f) => s(f, c) : (
+    // Support deprecated staggerChildren
+    r === 1 ? (f = 0) => f * i : (f = 0) => l - f * i
+  );
+  return Array.from(t.variantChildren).sort(Ho).forEach((f, h) => {
+    f.notify("AnimationStart", e), a.push(oe(f, e, {
+      ...o,
+      delay: n + (u ? 0 : s) + d(h)
+    }).then(() => f.notify("AnimationComplete", e)));
+  }), Promise.all(a);
+}
+function Ho(t, e) {
+  return t.sortNodePosition(e);
+}
+function zo(t, e, n = {}) {
+  t.notify("AnimationStart", e);
+  let s;
+  if (Array.isArray(e)) {
+    const i = e.map((r) => oe(t, r, n));
+    s = Promise.all(i);
+  } else if (typeof e == "string")
+    s = oe(t, e, n);
+  else {
+    const i = typeof e == "function" ? mt(t, e, n.custom) : e;
+    s = Promise.all(vs(t, i, n));
+  }
+  return s.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+function ws(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let s = 0; s < n; s++)
+    if (e[s] !== t[s])
+      return !1;
+  return !0;
+}
+const Yo = Me.length;
+function Ss(t) {
+  if (!t)
+    return;
+  if (!t.isControllingVariants) {
+    const n = t.parent ? Ss(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (n.initial = t.props.initial), n;
+  }
+  const e = {};
+  for (let n = 0; n < Yo; n++) {
+    const s = Me[n], i = t.props[s];
+    (pt(i) || i === !1) && (e[s] = i);
+  }
+  return e;
+}
+const Xo = [...xe].reverse(), qo = xe.length;
+function Zo(t) {
+  return (e) => Promise.all(e.map(({ animation: n, options: s }) => zo(t, n, s)));
+}
+function Jo(t) {
+  let e = Zo(t), n = an(), s = !0;
+  const i = (c) => (l, u) => {
+    var f;
+    const d = mt(t, u, c === "exit" ? (f = t.presenceContext) == null ? void 0 : f.custom : void 0);
+    if (d) {
+      const { transition: h, transitionEnd: y, ...b } = d;
+      l = { ...l, ...b, ...y };
+    }
+    return l;
+  };
+  function r(c) {
+    e = c(t);
+  }
+  function o(c) {
+    const { props: l } = t, u = Ss(t.parent) || {}, d = [], f = /* @__PURE__ */ new Set();
+    let h = {}, y = 1 / 0;
+    for (let v = 0; v < qo; v++) {
+      const p = Xo[v], S = n[p], m = l[p] !== void 0 ? l[p] : u[p], A = pt(m), T = p === c ? S.isActive : null;
+      T === !1 && (y = v);
+      let V = m === u[p] && m !== l[p] && A;
+      if (V && s && t.manuallyAnimateOnMount && (V = !1), S.protectedKeys = { ...h }, // If it isn't active and hasn't *just* been set as inactive
+      !S.isActive && T === null || // If we didn't and don't have any defined prop for this animation type
+      !m && !S.prevProp || // Or if the prop doesn't define an animation
+      Nt(m) || typeof m == "boolean")
+        continue;
+      const M = Qo(S.prevProp, m);
+      let w = M || // If we're making this variant active, we want to always make it active
+      p === c && S.isActive && !V && A || // If we removed a higher-priority variant (i is in reverse order)
+      v > y && A, F = !1;
+      const D = Array.isArray(m) ? m : [m];
+      let B = D.reduce(i(p), {});
+      T === !1 && (B = {});
+      const { prevResolvedValues: bt = {} } = S, Tt = {
+        ...bt,
+        ...B
+      }, vt = (P) => {
+        w = !0, f.has(P) && (F = !0, f.delete(P)), S.needsAnimating[P] = !0;
+        const O = t.getValue(P);
+        O && (O.liveStyle = !1);
+      };
+      for (const P in Tt) {
+        const O = B[P], wt = bt[P];
+        if (h.hasOwnProperty(P))
+          continue;
+        let Bt = !1;
+        re(O) && re(wt) ? Bt = !ws(O, wt) : Bt = O !== wt, Bt ? O != null ? vt(P) : f.add(P) : O !== void 0 && f.has(P) ? vt(P) : S.protectedKeys[P] = !0;
+      }
+      S.prevProp = m, S.prevResolvedValues = B, S.isActive && (h = { ...h, ...B }), s && t.blockInitialAnimation && (w = !1), w && (!(V && M) || F) && d.push(...D.map((P) => ({
+        animation: P,
+        options: { type: p }
+      })));
+    }
+    if (f.size) {
+      const v = {};
+      if (typeof l.initial != "boolean") {
+        const p = mt(t, Array.isArray(l.initial) ? l.initial[0] : l.initial);
+        p && p.transition && (v.transition = p.transition);
+      }
+      f.forEach((p) => {
+        const S = t.getBaseTarget(p), m = t.getValue(p);
+        m && (m.liveStyle = !0), v[p] = S ?? null;
+      }), d.push({ animation: v });
+    }
+    let b = !!d.length;
+    return s && (l.initial === !1 || l.initial === l.animate) && !t.manuallyAnimateOnMount && (b = !1), s = !1, b ? e(d) : Promise.resolve();
+  }
+  function a(c, l) {
+    var d;
+    if (n[c].isActive === l)
+      return Promise.resolve();
+    (d = t.variantChildren) == null || d.forEach((f) => {
+      var h;
+      return (h = f.animationState) == null ? void 0 : h.setActive(c, l);
+    }), n[c].isActive = l;
+    const u = o(c);
+    for (const f in n)
+      n[f].protectedKeys = {};
+    return u;
+  }
+  return {
+    animateChanges: o,
+    setActive: a,
+    setAnimateFunction: r,
+    getState: () => n,
+    reset: () => {
+      n = an(), s = !0;
+    }
+  };
+}
+function Qo(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !ws(e, t) : !1;
+}
+function G(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function an() {
+  return {
+    animate: G(!0),
+    whileInView: G(),
+    whileHover: G(),
+    whileTap: G(),
+    whileDrag: G(),
+    whileFocus: G(),
+    exit: G()
+  };
+}
+class ot {
+  constructor(e) {
+    this.isMounted = !1, this.node = e;
+  }
+  update() {
+  }
+}
+class ta extends ot {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(e) {
+    super(e), e.animationState || (e.animationState = Jo(e));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: e } = this.node.getProps();
+    Nt(e) && (this.unmountControls = e.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: e } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    e !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    var e;
+    this.node.animationState.reset(), (e = this.unmountControls) == null || e.call(this);
+  }
+}
+let ea = 0;
+class na extends ot {
+  constructor() {
+    super(...arguments), this.id = ea++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: e, onExitComplete: n } = this.node.presenceContext, { isPresent: s } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || e === s)
+      return;
+    const i = this.node.animationState.setActive("exit", !e);
+    n && !e && i.then(() => {
+      n(this.id);
+    });
+  }
+  mount() {
+    const { register: e, onExitComplete: n } = this.node.presenceContext || {};
+    n && n(this.id), e && (this.unmount = e(this.id));
+  }
+  unmount() {
+  }
+}
+const sa = {
+  animation: {
+    Feature: ta
+  },
+  exit: {
+    Feature: na
+  }
+};
+function un(t, e, n, s = { passive: !0 }) {
+  return t.addEventListener(e, n, s), () => t.removeEventListener(e, n);
+}
+function Vs(t) {
+  return {
+    point: {
+      x: t.pageX,
+      y: t.pageY
+    }
+  };
+}
+function ia({ top: t, left: e, right: n, bottom: s }) {
+  return {
+    x: { min: e, max: n },
+    y: { min: t, max: s }
+  };
+}
+function ra(t, e) {
+  if (!e)
+    return t;
+  const n = e({ x: t.left, y: t.top }), s = e({ x: t.right, y: t.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: s.y,
+    right: s.x
+  };
+}
+const cn = () => ({ min: 0, max: 0 }), As = () => ({
+  x: cn(),
+  y: cn()
+});
+function oa(t, e) {
+  return ia(ra(t.getBoundingClientRect(), e));
+}
+function ln(t, e, n) {
+  const { props: s } = t;
+  t.animationState && s.whileHover && t.animationState.setActive("whileHover", n === "Start");
+  const i = "onHover" + n, r = s[i];
+  r && N.postRender(() => r(e, Vs(e)));
+}
+class aa extends ot {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Br(e, (n, s) => (ln(this.node, s, "Start"), (i) => ln(this.node, i, "End"))));
+  }
+  unmount() {
+  }
+}
+class ua extends ot {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let e = !1;
+    try {
+      e = this.node.current.matches(":focus-visible");
+    } catch {
+      e = !0;
+    }
+    !e || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = It(un(this.node.current, "focus", () => this.onFocus()), un(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+function fn(t, e, n) {
+  const { props: s } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled)
+    return;
+  t.animationState && s.whileTap && t.animationState.setActive("whileTap", n === "Start");
+  const i = "onTap" + (n === "End" ? "" : n), r = s[i];
+  r && N.postRender(() => r(e, Vs(e)));
+}
+class ca extends ot {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Gr(e, (n, s) => (fn(this.node, s, "Start"), (i, { success: r }) => fn(this.node, i, r ? "End" : "Cancel")), { useGlobalTarget: this.node.props.globalTapTarget }));
+  }
+  unmount() {
+  }
+}
+const ae = /* @__PURE__ */ new WeakMap(), _t = /* @__PURE__ */ new WeakMap(), la = (t) => {
+  const e = ae.get(t.target);
+  e && e(t);
+}, fa = (t) => {
+  t.forEach(la);
+};
+function da({ root: t, ...e }) {
+  const n = t || document;
+  _t.has(n) || _t.set(n, {});
+  const s = _t.get(n), i = JSON.stringify(e);
+  return s[i] || (s[i] = new IntersectionObserver(fa, { root: t, ...e })), s[i];
+}
+function ha(t, e, n) {
+  const s = da(e);
+  return ae.set(t, n), s.observe(t), () => {
+    ae.delete(t), s.unobserve(t);
+  };
+}
+const pa = {
+  some: 0,
+  all: 1
+};
+class ma extends ot {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: e = {} } = this.node.getProps(), { root: n, margin: s, amount: i = "some", once: r } = e, o = {
+      root: n ? n.current : void 0,
+      rootMargin: s,
+      threshold: typeof i == "number" ? i : pa[i]
+    }, a = (c) => {
+      const { isIntersecting: l } = c;
+      if (this.isInView === l || (this.isInView = l, r && !l && this.hasEnteredView))
+        return;
+      l && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", l);
+      const { onViewportEnter: u, onViewportLeave: d } = this.node.getProps(), f = l ? u : d;
+      f && f(c);
+    };
+    return ha(this.node.current, o, a);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: e, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(ga(e, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function ga({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (n) => t[n] !== e[n];
+}
+const ya = {
+  inView: {
+    Feature: ma
+  },
+  tap: {
+    Feature: ca
+  },
+  focus: {
+    Feature: ua
+  },
+  hover: {
+    Feature: aa
+  }
+}, ue = { current: null }, xs = { current: !1 };
+function ba() {
+  if (xs.current = !0, !!le)
+    if (window.matchMedia) {
+      const t = window.matchMedia("(prefers-reduced-motion)"), e = () => ue.current = t.matches;
+      t.addEventListener("change", e), e();
+    } else
+      ue.current = !1;
+}
+const Ta = /* @__PURE__ */ new WeakMap();
+function va(t, e, n) {
+  for (const s in e) {
+    const i = e[s], r = n[s];
+    if (R(i))
+      t.addValue(s, i);
+    else if (R(r))
+      t.addValue(s, Ot(i, { owner: t }));
+    else if (r !== i)
+      if (t.hasValue(s)) {
+        const o = t.getValue(s);
+        o.liveStyle === !0 ? o.jump(i) : o.hasAnimated || o.set(i);
+      } else {
+        const o = t.getStaticValue(s);
+        t.addValue(s, Ot(o !== void 0 ? o : i, { owner: t }));
+      }
+  }
+  for (const s in n)
+    e[s] === void 0 && t.removeValue(s);
+  return e;
+}
+const dn = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class wa {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(e, n, s) {
+    return {};
+  }
+  constructor({ parent: e, props: n, presenceContext: s, reducedMotionConfig: i, blockInitialAnimation: r, visualState: o }, a = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = Se, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const f = E.now();
+      this.renderScheduledAt < f && (this.renderScheduledAt = f, N.render(this.render, !1, !0));
+    };
+    const { latestValues: c, renderState: l } = o;
+    this.latestValues = c, this.baseTarget = { ...c }, this.initialValues = n.initial ? { ...c } : {}, this.renderState = l, this.parent = e, this.props = n, this.presenceContext = s, this.depth = e ? e.depth + 1 : 0, this.reducedMotionConfig = i, this.options = a, this.blockInitialAnimation = !!r, this.isControllingVariants = Lt(n), this.isVariantNode = cs(n), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(e && e.current);
+    const { willChange: u, ...d } = this.scrapeMotionValuesFromProps(n, {}, this);
+    for (const f in d) {
+      const h = d[f];
+      c[f] !== void 0 && R(h) && h.set(c[f], !1);
+    }
+  }
+  mount(e) {
+    this.current = e, Ta.set(e, this), this.projection && !this.projection.instance && this.projection.mount(e), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((n, s) => this.bindToMotionValue(s, n)), xs.current || ba(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : ue.current, process.env.NODE_ENV !== "production" && wn(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), this.parent && this.parent.children.add(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    this.projection && this.projection.unmount(), Ut(this.notifyUpdate), Ut(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent && this.parent.children.delete(this);
+    for (const e in this.events)
+      this.events[e].clear();
+    for (const e in this.features) {
+      const n = this.features[e];
+      n && (n.unmount(), n.isMounted = !1);
+    }
+    this.current = null;
+  }
+  bindToMotionValue(e, n) {
+    this.valueSubscriptions.has(e) && this.valueSubscriptions.get(e)();
+    const s = rt.has(e);
+    s && this.onBindTransform && this.onBindTransform();
+    const i = n.on("change", (a) => {
+      this.latestValues[e] = a, this.props.onUpdate && N.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0);
+    }), r = n.on("renderRequest", this.scheduleRender);
+    let o;
+    window.MotionCheckAppearSync && (o = window.MotionCheckAppearSync(this, e, n)), this.valueSubscriptions.set(e, () => {
+      i(), r(), o && o(), n.owner && n.stop();
+    });
+  }
+  sortNodePosition(e) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== e.type ? 0 : this.sortInstanceNodePosition(this.current, e.current);
+  }
+  updateFeatures() {
+    let e = "animation";
+    for (e in J) {
+      const n = J[e];
+      if (!n)
+        continue;
+      const { isEnabled: s, Feature: i } = n;
+      if (!this.features[e] && i && s(this.props) && (this.features[e] = new i(this)), this.features[e]) {
+        const r = this.features[e];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : As();
+  }
+  getStaticValue(e) {
+    return this.latestValues[e];
+  }
+  setStaticValue(e, n) {
+    this.latestValues[e] = n;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(e, n) {
+    (e.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = e, this.prevPresenceContext = this.presenceContext, this.presenceContext = n;
+    for (let s = 0; s < dn.length; s++) {
+      const i = dn[s];
+      this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
+      const r = "on" + i, o = e[r];
+      o && (this.propEventSubscriptions[i] = this.on(i, o));
+    }
+    this.prevMotionValues = va(this, this.scrapeMotionValuesFromProps(e, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(e) {
+    return this.props.variants ? this.props.variants[e] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(e) {
+    const n = this.getClosestVariantNode();
+    if (n)
+      return n.variantChildren && n.variantChildren.add(e), () => n.variantChildren.delete(e);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(e, n) {
+    const s = this.values.get(e);
+    n !== s && (s && this.removeValue(e), this.bindToMotionValue(e, n), this.values.set(e, n), this.latestValues[e] = n.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(e) {
+    this.values.delete(e);
+    const n = this.valueSubscriptions.get(e);
+    n && (n(), this.valueSubscriptions.delete(e)), delete this.latestValues[e], this.removeValueFromRenderState(e, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(e) {
+    return this.values.has(e);
+  }
+  getValue(e, n) {
+    if (this.props.values && this.props.values[e])
+      return this.props.values[e];
+    let s = this.values.get(e);
+    return s === void 0 && n !== void 0 && (s = Ot(n === null ? void 0 : n, { owner: this }), this.addValue(e, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(e, n) {
+    let s = this.latestValues[e] !== void 0 || !this.current ? this.latestValues[e] : this.getBaseTargetFromProps(this.props, e) ?? this.readValueFromInstance(this.current, e, this.options);
+    return s != null && (typeof s == "string" && (gn(s) || yn(s)) ? s = parseFloat(s) : !Ur(s) && st.test(n) && (s = ss(e, n)), this.setBaseTarget(e, R(s) ? s.get() : s)), R(s) ? s.get() : s;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(e, n) {
+    this.baseTarget[e] = n;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(e) {
+    var r;
+    const { initial: n } = this.props;
+    let s;
+    if (typeof n == "string" || typeof n == "object") {
+      const o = De(this.props, n, (r = this.presenceContext) == null ? void 0 : r.custom);
+      o && (s = o[e]);
+    }
+    if (n && s !== void 0)
+      return s;
+    const i = this.getBaseTargetFromProps(this.props, e);
+    return i !== void 0 && !R(i) ? i : this.initialValues[e] !== void 0 && s === void 0 ? void 0 : this.baseTarget[e];
+  }
+  on(e, n) {
+    return this.events[e] || (this.events[e] = new Tn()), this.events[e].add(n);
+  }
+  notify(e, ...n) {
+    this.events[e] && this.events[e].notify(...n);
+  }
+}
+class Ms extends wa {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = Dr;
+  }
+  sortInstanceNodePosition(e, n) {
+    return e.compareDocumentPosition(n) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e.style ? e.style[n] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: n, style: s }) {
+    delete n[e], delete s[e];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    R(e) && (this.childSubscription = e.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+function Cs(t, { style: e, vars: n }, s, i) {
+  const r = t.style;
+  let o;
+  for (o in e)
+    r[o] = e[o];
+  i == null || i.applyProjectionStyles(r, s);
+  for (o in n)
+    r.setProperty(o, n[o]);
+}
+function Sa(t) {
+  return window.getComputedStyle(t);
+}
+class Va extends Ms {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = Cs;
+  }
+  readValueFromInstance(e, n) {
+    var s;
+    if (rt.has(n))
+      return (s = this.projection) != null && s.isProjecting ? Jt(n) : Xi(e, n);
+    {
+      const i = Sa(e), r = (In(n) ? i.getPropertyValue(n) : i[n]) || 0;
+      return typeof r == "string" ? r.trim() : r;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: n }) {
+    return oa(e, n);
+  }
+  build(e, n, s) {
+    Pe(e, n, s.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, n, s) {
+    return Re(e, n, s);
+  }
+}
+const Ps = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+function Aa(t, e, n, s) {
+  Cs(t, e, void 0, s);
+  for (const i in e.attrs)
+    t.setAttribute(Ps.has(i) ? i : Ce(i), e.attrs[i]);
+}
+class xa extends Ms {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = As;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e[n];
+  }
+  readValueFromInstance(e, n) {
+    if (rt.has(n)) {
+      const s = ns(n);
+      return s && s.default || 0;
+    }
+    return n = Ps.has(n) ? n : Ce(n), e.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(e, n, s) {
+    return Ts(e, n, s);
+  }
+  build(e, n, s) {
+    ms(e, n, this.isSVGTag, s.transformTemplate, s.style);
+  }
+  renderInstance(e, n, s, i) {
+    Aa(e, n, s, i);
+  }
+  mount(e) {
+    this.isSVGTag = ys(e.tagName), super.mount(e);
+  }
+}
+const Ma = (t, e) => Oe(t) ? new xa(e) : new Va(e, {
+  allowProjection: t !== pn
+}), Ca = {
+  renderer: Ma,
+  ...sa,
+  ...ya
+}, Pa = /* @__PURE__ */ Po("div"), Fa = {
   light: {
     border: "px",
     shadow: "2"
   },
   dark: {}
-}, O = a.createContext({
+}, Fs = ft.createContext({
   groupOpen: !1,
   setGroupOpen: () => {
   }
-}), U = ({ open: r, delay: o = 600 }) => {
-  const e = a.useContext(O);
-  return a.useEffect(() => {
-    let i = null;
-    return e.setGroupOpen && (r === !0 && e.setGroupOpen(!0), r === !1 && (i = setTimeout(() => {
-      e.setGroupOpen && e.setGroupOpen(!1);
-    }, o))), () => {
-      i && clearTimeout(i);
+}), Oa = ({ open: t, delay: e = 600 }) => {
+  const n = ft.useContext(Fs);
+  return ft.useEffect(() => {
+    let s = null;
+    return n.setGroupOpen && (t === !0 && n.setGroupOpen(!0), t === !1 && (s = setTimeout(() => {
+      n.setGroupOpen && n.setGroupOpen(!1);
+    }, e))), () => {
+      s && clearTimeout(s);
     };
-  }, [r, e, o]), {
-    groupOpen: e.groupOpen
+  }, [t, n, e]), {
+    groupOpen: n.groupOpen
   };
-}, oe = ({ children: r }) => {
-  const [o, e] = a.useState(!1);
-  return /* @__PURE__ */ t(O.Provider, { value: { groupOpen: o, setGroupOpen: e }, children: r });
-}, ne = ({
+}, Wa = ({ children: t }) => {
+  const [e, n] = ft.useState(!1);
+  return /* @__PURE__ */ I(Fs.Provider, { value: { groupOpen: e, setGroupOpen: n }, children: t });
+}, $a = ({
   // Radix Tooltip Provider Props
-  delayDuration: r = 400,
-  skipDelayDuration: o,
-  disableHoverableContent: e,
+  delayDuration: t = 400,
+  skipDelayDuration: e,
+  disableHoverableContent: n,
   // Radix Tooltip Root Props
-  defaultOpen: i,
-  open: g,
-  onOpenChange: h,
+  defaultOpen: s,
+  open: i,
+  onOpenChange: r,
   // Radix Tooltip Content Props
-  "aria-label": T,
-  onEscapeKeyDown: x,
-  onPointerDownOutside: y,
-  forceMount: C,
-  side: l = "bottom",
-  sideOffset: A = 4,
-  align: v = "center",
-  alignOffset: G,
-  avoidCollisions: I,
-  collisionBoundary: N,
-  collisionPadding: S,
-  arrowPadding: b,
-  sticky: F,
-  hideWhenDetached: E,
-  skipAnimation: P,
+  "aria-label": o,
+  onEscapeKeyDown: a,
+  onPointerDownOutside: c,
+  forceMount: l,
+  side: u = "bottom",
+  sideOffset: d = 4,
+  align: f = "center",
+  alignOffset: h,
+  avoidCollisions: y,
+  collisionBoundary: b,
+  collisionPadding: v,
+  arrowPadding: p,
+  sticky: S,
+  hideWhenDetached: m,
+  skipAnimation: A,
   // Label Props
-  label: s,
-  labelProps: u,
+  label: T,
+  labelProps: V,
   // Telegraph Props
-  enabled: R = !0,
-  appearance: c = "dark",
-  triggerRef: j,
-  children: f
+  enabled: M = !0,
+  appearance: w = "dark",
+  triggerRef: F,
+  children: D
 }) => {
-  const [d, k] = B({
-    prop: g,
-    onChange: h,
-    defaultProp: i
-  }), { groupOpen: m } = U({ open: !!d, delay: r }), z = a.Children.toArray(f).some(
-    (n) => n.props.disabled
-  ), D = m || z ? 0 : r, M = !m, _ = (n) => {
-    if (n === "top")
+  const [B, bt] = Os({
+    prop: i,
+    onChange: r,
+    defaultProp: s ?? !1
+  }), { groupOpen: Tt } = Oa({ open: !!B, delay: t }), vt = ft.Children.toArray(D).some(
+    (O) => O.props.disabled
+  ), Ie = Tt || vt ? 0 : t, Ee = !Tt, P = (O) => {
+    if (O === "top")
       return {
         y: -5
       };
-    if (n === "bottom")
+    if (O === "bottom")
       return {
         y: 5
       };
-    if (n === "left")
+    if (O === "left")
       return {
         x: -5
       };
-    if (n === "right")
+    if (O === "right")
       return {
         x: 5
       };
   };
-  return /* @__PURE__ */ t(
-    p.Provider,
+  return /* @__PURE__ */ I(Hr, { features: Ca, children: /* @__PURE__ */ I(
+    at.Provider,
     {
-      delayDuration: D,
-      skipDelayDuration: o,
-      disableHoverableContent: e,
-      children: /* @__PURE__ */ w(
-        p.Root,
+      delayDuration: Ie,
+      skipDelayDuration: e,
+      disableHoverableContent: n,
+      children: /* @__PURE__ */ hn(
+        at.Root,
         {
-          open: R === !1 ? !1 : d,
-          onOpenChange: k,
+          open: M === !1 ? !1 : B,
+          onOpenChange: bt,
           children: [
-            /* @__PURE__ */ t(p.Trigger, { asChild: !0, ref: j, children: /* @__PURE__ */ t(H, { children: f }) }),
-            /* @__PURE__ */ t(p.Portal, { children: /* @__PURE__ */ t(
-              p.Content,
+            /* @__PURE__ */ I(at.Trigger, { asChild: !0, ref: F, children: /* @__PURE__ */ I(Rs, { children: D }) }),
+            /* @__PURE__ */ I(at.Portal, { children: /* @__PURE__ */ I(
+              at.Content,
               {
-                "aria-label": T,
-                onEscapeKeyDown: x,
-                onPointerDownOutside: y,
-                forceMount: C,
-                side: l,
-                sideOffset: A,
-                align: v,
-                alignOffset: G,
-                avoidCollisions: I,
-                collisionBoundary: N,
-                collisionPadding: S,
-                arrowPadding: b,
-                sticky: F,
-                hideWhenDetached: E,
+                "aria-label": o,
+                onEscapeKeyDown: a,
+                onPointerDownOutside: c,
+                forceMount: l,
+                side: u,
+                sideOffset: d,
+                align: f,
+                alignOffset: h,
+                avoidCollisions: y,
+                collisionBoundary: b,
+                collisionPadding: v,
+                arrowPadding: p,
+                sticky: S,
+                hideWhenDetached: m,
                 style: {
                   zIndex: "var(--tgph-zIndex-tooltip)"
                 },
-                children: /* @__PURE__ */ t(q, { appearance: c, asChild: !0, children: /* @__PURE__ */ t(
-                  J,
+                children: /* @__PURE__ */ I(Ds, { appearance: w, asChild: !0, children: /* @__PURE__ */ I(
+                  Is,
                   {
-                    as: K.div,
+                    as: Pa,
                     className: "tgph",
-                    skipAnimation: P,
-                    initial: M ? {
+                    initial: Ee && !A ? {
                       opacity: 0,
                       scale: 0.5,
-                      ..._(l)
+                      ...P(u)
                     } : {},
                     animate: {
                       opacity: 1,
@@ -141,8 +3400,9 @@ const Q = {
                       y: 0
                     },
                     transition: {
-                      duration: 100,
-                      type: "spring"
+                      duration: 0.1,
+                      type: "spring",
+                      bounce: 0
                     },
                     bg: "gray-1",
                     rounded: "3",
@@ -153,9 +3413,9 @@ const Q = {
                     style: {
                       transformOrigin: "var(--radix-tooltip-content-transform-origin)"
                     },
-                    ...u ? { labelProps: u } : {},
-                    ...Q[c],
-                    children: typeof s == "string" ? /* @__PURE__ */ t(L, { as: "span", size: "1", children: s }) : s
+                    ...V ? { labelProps: V } : {},
+                    ...Fa[w],
+                    children: typeof T == "string" ? /* @__PURE__ */ I(Es, { as: "span", size: "1", children: T }) : T
                   }
                 ) })
               }
@@ -164,10 +3424,10 @@ const Q = {
         }
       )
     }
-  );
+  ) });
 };
 export {
-  ne as Tooltip,
-  oe as TooltipGroupProvider
+  $a as Tooltip,
+  Wa as TooltipGroupProvider
 };
 //# sourceMappingURL=index.mjs.map