@g4rcez/components 3.0.1 → 3.0.2

package/dist/proxy-BZcQiBrp.js

@@ -0,0 +1,2495 @@
+import { jsx as N, Fragment as $n, jsxs as Xn } from "react/jsx-runtime";
+import * as Pt from "react";
+import { createContext as nt, useLayoutEffect as Yn, useEffect as Wt, useId as Ht, useRef as j, useContext as C, useInsertionEffect as Nt, useMemo as z, useCallback as qe, Children as _n, isValidElement as Kn, useState as Qt, Fragment as Ze, createElement as qn, forwardRef as Zn, Component as Jn } from "react";
+import { G as Z, x as Je, I as Qn, r as Qe, o as tn, J as pt, K as en, L as zt, N as te, O as nn, m as D, P as gt, Q as ee, R as ti, n as jt, T as K, U as ei, W as sn, b as It, X as on, C as A, D as tt, d as Gt, Y as ni, q as ii, Z as si, _ as rn, $ as R, a0 as St, a1 as an, c as E, a2 as $, a3 as ot, a4 as rt, a5 as ne, a6 as oi, a7 as ri, a8 as ai, a9 as Y, y as li, t as ci, aa as ie, ab as ui, M as $t, u as Xt, ac as hi, ad as ln, ae as cn, af as fi, ag as di, ah as mi, ai as pi, aj as gi, ak as yi, al as vi, am as Pi, an as xi, ao as wi, l as un, w as Ti, S as Si, H as Ei, ap as hn, s as se, aq as Di, ar as Ai, as as Ci, at as Li, au as oe, av as Vi } from "./MotionConfigContext-C7MqlSdv.js";
+const Yt = nt({}), fn = typeof window < "u", dn = fn ? Yn : Wt, xt = /* @__PURE__ */ nt(null);
+function mn(t, e, n, i = 0, o = 1) {
+  const a = Array.from(t).sort((c, u) => c.sortNodePosition(u)).indexOf(e), s = t.size, r = (s - 1) * i;
+  return typeof n == "function" ? n(a, s) : o === 1 ? a * i : r - a * i;
+}
+function Bt(t, e, n = {}) {
+  const i = Z(t, e, n.type === "exit" ? t.presenceContext?.custom : void 0);
+  let { transition: o = t.getDefaultTransition() || {} } = i || {};
+  n.transitionOverride && (o = n.transitionOverride);
+  const a = i ? () => Promise.all(Je(t, i, n)) : () => Promise.resolve(), s = t.variantChildren && t.variantChildren.size ? (l = 0) => {
+    const { delayChildren: c = 0, staggerChildren: u, staggerDirection: f } = o;
+    return Ri(t, e, l, c, u, f, n);
+  } : () => Promise.resolve(), { when: r } = o;
+  if (r) {
+    const [l, c] = r === "beforeChildren" ? [a, s] : [s, a];
+    return l().then(() => c());
+  } else
+    return Promise.all([a(), s(n.delay)]);
+}
+function Ri(t, e, n = 0, i = 0, o = 0, a = 1, s) {
+  const r = [];
+  for (const l of t.variantChildren)
+    l.notify("AnimationStart", e), r.push(Bt(l, e, {
+      ...s,
+      delay: n + (typeof i == "function" ? 0 : i) + mn(t.variantChildren, l, i, o, a)
+    }).then(() => l.notify("AnimationComplete", e)));
+  return Promise.all(r);
+}
+function bi(t, e, n = {}) {
+  t.notify("AnimationStart", e);
+  let i;
+  if (Array.isArray(e)) {
+    const o = e.map((a) => Bt(t, a, n));
+    i = Promise.all(o);
+  } else if (typeof e == "string")
+    i = Bt(t, e, n);
+  else {
+    const o = typeof e == "function" ? Z(t, e, n.custom) : e;
+    i = Promise.all(Je(t, o, n));
+  }
+  return i.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+function Ot(t) {
+  return Qn(t) && "offsetHeight" in t;
+}
+const k = {
+  x: !1,
+  y: !1
+};
+function pn() {
+  return k.x || k.y;
+}
+function Mi(t) {
+  return t === "x" || t === "y" ? k[t] ? null : (k[t] = !0, () => {
+    k[t] = !1;
+  }) : k.x || k.y ? null : (k.x = k.y = !0, () => {
+    k.x = k.y = !1;
+  });
+}
+function gn(t, e) {
+  const n = Qe(t), i = new AbortController(), o = {
+    passive: !0,
+    ...e,
+    signal: i.signal
+  };
+  return [n, o, () => i.abort()];
+}
+function ki(t) {
+  return !(t.pointerType === "touch" || pn());
+}
+function ji(t, e, n = {}) {
+  const [i, o, a] = gn(t, n);
+  return i.forEach((s) => {
+    let r = !1, l = !1, c;
+    const u = () => {
+      s.removeEventListener("pointerleave", m);
+    }, f = (g) => {
+      c && (c(g), c = void 0), u();
+    }, h = (g) => {
+      r = !1, window.removeEventListener("pointerup", h), window.removeEventListener("pointercancel", h), l && (l = !1, f(g));
+    }, d = () => {
+      r = !0, window.addEventListener("pointerup", h, o), window.addEventListener("pointercancel", h, o);
+    }, m = (g) => {
+      if (g.pointerType !== "touch") {
+        if (r) {
+          l = !0;
+          return;
+        }
+        f(g);
+      }
+    }, P = (g) => {
+      if (!ki(g))
+        return;
+      l = !1;
+      const p = e(s, g);
+      typeof p == "function" && (c = p, s.addEventListener("pointerleave", m, o));
+    };
+    s.addEventListener("pointerenter", P, o), s.addEventListener("pointerdown", d, o);
+  }), a;
+}
+const yn = (t, e) => e ? t === e ? !0 : yn(t, e.parentElement) : !1, _t = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, Ii = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function Bi(t) {
+  return Ii.has(t.tagName) || t.isContentEditable === !0;
+}
+const Oi = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
+function Fi(t) {
+  return Oi.has(t.tagName) || t.isContentEditable === !0;
+}
+const ct = /* @__PURE__ */ new WeakSet();
+function re(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function Et(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
+}
+const Ui = (t, e) => {
+  const n = t.currentTarget;
+  if (!n)
+    return;
+  const i = re(() => {
+    if (ct.has(n))
+      return;
+    Et(n, "down");
+    const o = re(() => {
+      Et(n, "up");
+    }), a = () => Et(n, "cancel");
+    n.addEventListener("keyup", o, e), n.addEventListener("blur", a, e);
+  });
+  n.addEventListener("keydown", i, e), n.addEventListener("blur", () => n.removeEventListener("keydown", i), e);
+};
+function ae(t) {
+  return _t(t) && !pn();
+}
+const le = /* @__PURE__ */ new WeakSet();
+function Wi(t, e, n = {}) {
+  const [i, o, a] = gn(t, n), s = (r) => {
+    const l = r.currentTarget;
+    if (!ae(r) || le.has(r))
+      return;
+    ct.add(l), n.stopPropagation && le.add(r);
+    const c = e(l, r), u = (d, m) => {
+      window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", h), ct.has(l) && ct.delete(l), ae(d) && typeof c == "function" && c(d, { success: m });
+    }, f = (d) => {
+      u(d, l === window || l === document || n.useGlobalTarget || yn(l, d.target));
+    }, h = (d) => {
+      u(d, !1);
+    };
+    window.addEventListener("pointerup", f, o), window.addEventListener("pointercancel", h, o);
+  };
+  return i.forEach((r) => {
+    (n.useGlobalTarget ? window : r).addEventListener("pointerdown", s, o), Ot(r) && (r.addEventListener("focus", (c) => Ui(c, o)), !Bi(r) && !r.hasAttribute("tabindex") && (r.tabIndex = 0));
+  }), a;
+}
+const ut = /* @__PURE__ */ new WeakMap();
+let ht;
+const vn = (t, e, n) => (i, o) => o && o[0] ? o[0][t + "Size"] : tn(i) && "getBBox" in i ? i.getBBox()[e] : i[n], Hi = /* @__PURE__ */ vn("inline", "width", "offsetWidth"), Ni = /* @__PURE__ */ vn("block", "height", "offsetHeight");
+function zi({ target: t, borderBoxSize: e }) {
+  ut.get(t)?.forEach((n) => {
+    n(t, {
+      get width() {
+        return Hi(t, e);
+      },
+      get height() {
+        return Ni(t, e);
+      }
+    });
+  });
+}
+function Gi(t) {
+  t.forEach(zi);
+}
+function $i() {
+  typeof ResizeObserver > "u" || (ht = new ResizeObserver(Gi));
+}
+function Xi(t, e) {
+  ht || $i();
+  const n = Qe(t);
+  return n.forEach((i) => {
+    let o = ut.get(i);
+    o || (o = /* @__PURE__ */ new Set(), ut.set(i, o)), o.add(e), ht?.observe(i);
+  }), () => {
+    n.forEach((i) => {
+      const o = ut.get(i);
+      o?.delete(e), o?.size || ht?.unobserve(i);
+    });
+  };
+}
+const ft = /* @__PURE__ */ new Set();
+let _;
+function Yi() {
+  _ = () => {
+    const t = {
+      get width() {
+        return window.innerWidth;
+      },
+      get height() {
+        return window.innerHeight;
+      }
+    };
+    ft.forEach((e) => e(t));
+  }, window.addEventListener("resize", _);
+}
+function _i(t) {
+  return ft.add(t), _ || Yi(), () => {
+    ft.delete(t), !ft.size && typeof _ == "function" && (window.removeEventListener("resize", _), _ = void 0);
+  };
+}
+function ce(t, e) {
+  return typeof t == "function" ? _i(t) : Xi(t, e);
+}
+class U {
+  constructor(e) {
+    this.isMounted = !1, this.node = e;
+  }
+  update() {
+  }
+}
+const Ki = en.length;
+function Pn(t) {
+  if (!t)
+    return;
+  if (!t.isControllingVariants) {
+    const n = t.parent ? Pn(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (n.initial = t.props.initial), n;
+  }
+  const e = {};
+  for (let n = 0; n < Ki; n++) {
+    const i = en[n], o = t.props[i];
+    (pt(o) || o === !1) && (e[i] = o);
+  }
+  return e;
+}
+function xn(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let i = 0; i < n; i++)
+    if (e[i] !== t[i])
+      return !1;
+  return !0;
+}
+const qi = [...nn].reverse(), Zi = nn.length;
+function Ji(t) {
+  return (e) => Promise.all(e.map(({ animation: n, options: i }) => bi(t, n, i)));
+}
+function Qi(t) {
+  let e = Ji(t), n = ue(), i = !0;
+  const o = (l) => (c, u) => {
+    const f = Z(t, u, l === "exit" ? t.presenceContext?.custom : void 0);
+    if (f) {
+      const { transition: h, transitionEnd: d, ...m } = f;
+      c = { ...c, ...m, ...d };
+    }
+    return c;
+  };
+  function a(l) {
+    e = l(t);
+  }
+  function s(l) {
+    const { props: c } = t, u = Pn(t.parent) || {}, f = [], h = /* @__PURE__ */ new Set();
+    let d = {}, m = 1 / 0;
+    for (let g = 0; g < Zi; g++) {
+      const p = qi[g], y = n[p], v = c[p] !== void 0 ? c[p] : u[p], x = pt(v), T = p === l ? y.isActive : null;
+      T === !1 && (m = g);
+      let F = v === u[p] && v !== c[p] && x;
+      if (F && i && t.manuallyAnimateOnMount && (F = !1), y.protectedKeys = { ...d }, // If it isn't active and hasn't *just* been set as inactive
+      !y.isActive && T === null || // If we didn't and don't have any defined prop for this animation type
+      !v && !y.prevProp || // Or if the prop doesn't define an animation
+      zt(v) || typeof v == "boolean")
+        continue;
+      if (p === "exit" && y.isActive && T !== !0) {
+        y.prevResolvedValues && (d = {
+          ...d,
+          ...y.prevResolvedValues
+        });
+        continue;
+      }
+      const st = ts(y.prevProp, v);
+      let V = st || // If we're making this variant active, we want to always make it active
+      p === l && y.isActive && !F && x || // If we removed a higher-priority variant (i is in reverse order)
+      g > m && x, w = !1;
+      const B = Array.isArray(v) ? v : [v];
+      let O = B.reduce(o(p), {});
+      T === !1 && (O = {});
+      const { prevResolvedValues: q = {} } = y, Tt = {
+        ...q,
+        ...O
+      }, Zt = (S) => {
+        V = !0, h.has(S) && (w = !0, h.delete(S)), y.needsAnimating[S] = !0;
+        const b = t.getValue(S);
+        b && (b.liveStyle = !1);
+      };
+      for (const S in Tt) {
+        const b = O[S], W = q[S];
+        if (d.hasOwnProperty(S))
+          continue;
+        let G = !1;
+        te(b) && te(W) ? G = !xn(b, W) : G = b !== W, G ? b != null ? Zt(S) : h.add(S) : b !== void 0 && h.has(S) ? Zt(S) : y.protectedKeys[S] = !0;
+      }
+      y.prevProp = v, y.prevResolvedValues = O, y.isActive && (d = { ...d, ...O }), i && t.blockInitialAnimation && (V = !1);
+      const Jt = F && st;
+      V && (!Jt || w) && f.push(...B.map((S) => {
+        const b = { type: p };
+        if (typeof S == "string" && i && !Jt && t.manuallyAnimateOnMount && t.parent) {
+          const { parent: W } = t, G = Z(W, S);
+          if (W.enteringChildren && G) {
+            const { delayChildren: Gn } = G.transition || {};
+            b.delay = mn(W.enteringChildren, t, Gn);
+          }
+        }
+        return {
+          animation: S,
+          options: b
+        };
+      }));
+    }
+    if (h.size) {
+      const g = {};
+      if (typeof c.initial != "boolean") {
+        const p = Z(t, Array.isArray(c.initial) ? c.initial[0] : c.initial);
+        p && p.transition && (g.transition = p.transition);
+      }
+      h.forEach((p) => {
+        const y = t.getBaseTarget(p), v = t.getValue(p);
+        v && (v.liveStyle = !0), g[p] = y ?? null;
+      }), f.push({ animation: g });
+    }
+    let P = !!f.length;
+    return i && (c.initial === !1 || c.initial === c.animate) && !t.manuallyAnimateOnMount && (P = !1), i = !1, P ? e(f) : Promise.resolve();
+  }
+  function r(l, c) {
+    if (n[l].isActive === c)
+      return Promise.resolve();
+    t.variantChildren?.forEach((f) => f.animationState?.setActive(l, c)), n[l].isActive = c;
+    const u = s(l);
+    for (const f in n)
+      n[f].protectedKeys = {};
+    return u;
+  }
+  return {
+    animateChanges: s,
+    setActive: r,
+    setAnimateFunction: a,
+    getState: () => n,
+    reset: () => {
+      n = ue();
+    }
+  };
+}
+function ts(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !xn(e, t) : !1;
+}
+function H(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function ue() {
+  return {
+    animate: H(!0),
+    whileInView: H(),
+    whileHover: H(),
+    whileTap: H(),
+    whileDrag: H(),
+    whileFocus: H(),
+    exit: H()
+  };
+}
+function he(t, e) {
+  t.min = e.min, t.max = e.max;
+}
+function M(t, e) {
+  he(t.x, e.x), he(t.y, e.y);
+}
+function fe(t, e) {
+  t.translate = e.translate, t.scale = e.scale, t.originPoint = e.originPoint, t.origin = e.origin;
+}
+const wn = 1e-4, es = 1 - wn, ns = 1 + wn, Tn = 0.01, is = 0 - Tn, ss = 0 + Tn;
+function L(t) {
+  return t.max - t.min;
+}
+function os(t, e, n) {
+  return Math.abs(t - e) <= n;
+}
+function de(t, e, n, i = 0.5) {
+  t.origin = i, t.originPoint = D(e.min, e.max, t.origin), t.scale = L(n) / L(e), t.translate = D(n.min, n.max, t.origin) - t.originPoint, (t.scale >= es && t.scale <= ns || isNaN(t.scale)) && (t.scale = 1), (t.translate >= is && t.translate <= ss || isNaN(t.translate)) && (t.translate = 0);
+}
+function J(t, e, n, i) {
+  de(t.x, e.x, n.x, i ? i.originX : void 0), de(t.y, e.y, n.y, i ? i.originY : void 0);
+}
+function me(t, e, n) {
+  t.min = n.min + e.min, t.max = t.min + L(e);
+}
+function rs(t, e, n) {
+  me(t.x, e.x, n.x), me(t.y, e.y, n.y);
+}
+function pe(t, e, n) {
+  t.min = e.min - n.min, t.max = t.min + L(e);
+}
+function yt(t, e, n) {
+  pe(t.x, e.x, n.x), pe(t.y, e.y, n.y);
+}
+function ge(t, e, n, i, o) {
+  return t -= e, t = ee(t, 1 / n, i), o !== void 0 && (t = ee(t, 1 / o, i)), t;
+}
+function as(t, e = 0, n = 1, i = 0.5, o, a = t, s = t) {
+  if (gt.test(e) && (e = parseFloat(e), e = D(s.min, s.max, e / 100) - s.min), typeof e != "number")
+    return;
+  let r = D(a.min, a.max, i);
+  t === a && (r -= e), t.min = ge(t.min, e, n, r, o), t.max = ge(t.max, e, n, r, o);
+}
+function ye(t, e, [n, i, o], a, s) {
+  as(t, e[n], e[i], e[o], e.scale, a, s);
+}
+const ls = ["x", "scaleX", "originX"], cs = ["y", "scaleY", "originY"];
+function ve(t, e, n, i) {
+  ye(t.x, e, ls, n ? n.x : void 0, i ? i.x : void 0), ye(t.y, e, cs, n ? n.y : void 0, i ? i.y : void 0);
+}
+function Pe(t) {
+  return t.translate === 0 && t.scale === 1;
+}
+function Sn(t) {
+  return Pe(t.x) && Pe(t.y);
+}
+function xe(t, e) {
+  return t.min === e.min && t.max === e.max;
+}
+function us(t, e) {
+  return xe(t.x, e.x) && xe(t.y, e.y);
+}
+function we(t, e) {
+  return Math.round(t.min) === Math.round(e.min) && Math.round(t.max) === Math.round(e.max);
+}
+function En(t, e) {
+  return we(t.x, e.x) && we(t.y, e.y);
+}
+function Te(t) {
+  return L(t.x) / L(t.y);
+}
+function Se(t, e) {
+  return t.translate === e.translate && t.scale === e.scale && t.originPoint === e.originPoint;
+}
+function I(t) {
+  return [t("x"), t("y")];
+}
+function hs(t, e, n) {
+  let i = "";
+  const o = t.x.translate / e.x, a = t.y.translate / e.y, s = n?.z || 0;
+  if ((o || a || s) && (i = `translate3d(${o}px, ${a}px, ${s}px) `), (e.x !== 1 || e.y !== 1) && (i += `scale(${1 / e.x}, ${1 / e.y}) `), n) {
+    const { transformPerspective: c, rotate: u, rotateX: f, rotateY: h, skewX: d, skewY: m } = n;
+    c && (i = `perspective(${c}px) ${i}`), u && (i += `rotate(${u}deg) `), f && (i += `rotateX(${f}deg) `), h && (i += `rotateY(${h}deg) `), d && (i += `skewX(${d}deg) `), m && (i += `skewY(${m}deg) `);
+  }
+  const r = t.x.scale * e.x, l = t.y.scale * e.y;
+  return (r !== 1 || l !== 1) && (i += `scale(${r}, ${l})`), i || "none";
+}
+const Dn = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"], fs = Dn.length, Ee = (t) => typeof t == "string" ? parseFloat(t) : t, De = (t) => typeof t == "number" || ti.test(t);
+function ds(t, e, n, i, o, a) {
+  o ? (t.opacity = D(0, n.opacity ?? 1, ms(i)), t.opacityExit = D(e.opacity ?? 1, 0, ps(i))) : a && (t.opacity = D(e.opacity ?? 1, n.opacity ?? 1, i));
+  for (let s = 0; s < fs; s++) {
+    const r = `border${Dn[s]}Radius`;
+    let l = Ae(e, r), c = Ae(n, r);
+    if (l === void 0 && c === void 0)
+      continue;
+    l || (l = 0), c || (c = 0), l === 0 || c === 0 || De(l) === De(c) ? (t[r] = Math.max(D(Ee(l), Ee(c), i), 0), (gt.test(c) || gt.test(l)) && (t[r] += "%")) : t[r] = c;
+  }
+  (e.rotate || n.rotate) && (t.rotate = D(e.rotate || 0, n.rotate || 0, i));
+}
+function Ae(t, e) {
+  return t[e] !== void 0 ? t[e] : t.borderRadius;
+}
+const ms = /* @__PURE__ */ An(0, 0.5, ei), ps = /* @__PURE__ */ An(0.5, 0.95, K);
+function An(t, e, n) {
+  return (i) => i < t ? 0 : i > e ? 1 : n(jt(t, e, i));
+}
+function et(t, e, n, i = { passive: !0 }) {
+  return t.addEventListener(e, n, i), () => t.removeEventListener(e, n);
+}
+const gs = (t, e) => t.depth - e.depth;
+class ys {
+  constructor() {
+    this.children = [], this.isDirty = !1;
+  }
+  add(e) {
+    sn(this.children, e), this.isDirty = !0;
+  }
+  remove(e) {
+    It(this.children, e), this.isDirty = !0;
+  }
+  forEach(e) {
+    this.isDirty && this.children.sort(gs), this.isDirty = !1, this.children.forEach(e);
+  }
+}
+function vs(t, e) {
+  const n = on.now(), i = ({ timestamp: o }) => {
+    const a = o - n;
+    a >= e && (tt(i), t(a - e));
+  };
+  return A.setup(i, !0), () => tt(i);
+}
+function dt(t) {
+  return Gt(t) ? t.get() : t;
+}
+class Ps {
+  constructor() {
+    this.members = [];
+  }
+  add(e) {
+    sn(this.members, e);
+    for (let n = this.members.length - 1; n >= 0; n--) {
+      const i = this.members[n];
+      if (i === e || i === this.lead || i === this.prevLead)
+        continue;
+      const o = i.instance;
+      o && o.isConnected === !1 && i.isPresent !== !1 && !i.snapshot && It(this.members, i);
+    }
+    e.scheduleRender();
+  }
+  remove(e) {
+    if (It(this.members, e), e === this.prevLead && (this.prevLead = void 0), e === this.lead) {
+      const n = this.members[this.members.length - 1];
+      n && this.promote(n);
+    }
+  }
+  relegate(e) {
+    const n = this.members.findIndex((o) => e === o);
+    if (n === 0)
+      return !1;
+    let i;
+    for (let o = n; o >= 0; o--) {
+      const a = this.members[o], s = a.instance;
+      if (a.isPresent !== !1 && (!s || s.isConnected !== !1)) {
+        i = a;
+        break;
+      }
+    }
+    return i ? (this.promote(i), !0) : !1;
+  }
+  promote(e, n) {
+    const i = this.lead;
+    if (e !== i && (this.prevLead = i, this.lead = e, e.show(), i)) {
+      i.instance && i.scheduleRender(), e.scheduleRender();
+      const o = i.options.layoutDependency, a = e.options.layoutDependency;
+      if (!(o !== void 0 && a !== void 0 && o === a)) {
+        const l = i.instance;
+        l && l.isConnected === !1 && !i.snapshot || (e.resumeFrom = i, n && (e.resumeFrom.preserveOpacity = !0), i.snapshot && (e.snapshot = i.snapshot, e.snapshot.latestValues = i.animationValues || i.latestValues), e.root && e.root.isUpdating && (e.isLayoutDirty = !0));
+      }
+      const { crossfade: r } = e.options;
+      r === !1 && i.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((e) => {
+      const { options: n, resumingFrom: i } = e;
+      n.onExitComplete && n.onExitComplete(), i && i.options.onExitComplete && i.options.onExitComplete();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((e) => {
+      e.instance && e.scheduleRender(!1);
+    });
+  }
+  /**
+   * Clear any leads that have been removed this render to prevent them from being
+   * used in future animations and to prevent memory leaks
+   */
+  removeLeadSnapshot() {
+    this.lead && this.lead.snapshot && (this.lead.snapshot = void 0);
+  }
+}
+const mt = {
+  /**
+   * Global flag as to whether the tree has animated since the last time
+   * we resized the window
+   */
+  hasAnimatedSinceResize: !0,
+  /**
+   * We set this to true once, on the first update. Any nodes added to the tree beyond that
+   * update will be given a `data-projection-id` attribute.
+   */
+  hasEverUpdated: !1
+}, Dt = ["", "X", "Y", "Z"], xs = 1e3;
+let ws = 0;
+function At(t, e, n, i) {
+  const { latestValues: o } = e;
+  o[t] && (n[t] = o[t], e.setStaticValue(t, 0), i && (i[t] = 0));
+}
+function Cn(t) {
+  if (t.hasCheckedOptimisedAppear = !0, t.root === t)
+    return;
+  const { visualElement: e } = t.options;
+  if (!e)
+    return;
+  const n = ui(e);
+  if (window.MotionHasOptimisedAnimation(n, "transform")) {
+    const { layout: o, layoutId: a } = t.options;
+    window.MotionCancelOptimisedAnimation(n, "transform", A, !(o || a));
+  }
+  const { parent: i } = t;
+  i && !i.hasCheckedOptimisedAppear && Cn(i);
+}
+function Ln({ attachResizeListener: t, defaultParent: e, measureScroll: n, checkIsScrollRoot: i, resetTransform: o }) {
+  return class {
+    constructor(s = {}, r = e?.()) {
+      this.id = ws++, this.animationId = 0, this.animationCommitId = 0, this.children = /* @__PURE__ */ new Set(), this.options = {}, this.isTreeAnimating = !1, this.isAnimationBlocked = !1, this.isLayoutDirty = !1, this.isProjectionDirty = !1, this.isSharedProjectionDirty = !1, this.isTransformDirty = !1, this.updateManuallyBlocked = !1, this.updateBlockedByResize = !1, this.isUpdating = !1, this.isSVG = !1, this.needsReset = !1, this.shouldResetTransform = !1, this.hasCheckedOptimisedAppear = !1, this.treeScale = { x: 1, y: 1 }, this.eventHandlers = /* @__PURE__ */ new Map(), this.hasTreeAnimated = !1, this.layoutVersion = 0, this.updateScheduled = !1, this.scheduleUpdate = () => this.update(), this.projectionUpdateScheduled = !1, this.checkUpdateFailed = () => {
+        this.isUpdating && (this.isUpdating = !1, this.clearAllSnapshots());
+      }, this.updateProjection = () => {
+        this.projectionUpdateScheduled = !1, this.nodes.forEach(Es), this.nodes.forEach(Ls), this.nodes.forEach(Vs), this.nodes.forEach(Ds);
+      }, this.resolvedRelativeTargetAt = 0, this.linkedParentVersion = 0, this.hasProjected = !1, this.isVisible = !0, this.animationProgress = 0, this.sharedNodes = /* @__PURE__ */ new Map(), this.latestValues = s, this.root = r ? r.root || r : this, this.path = r ? [...r.path, r] : [], this.parent = r, this.depth = r ? r.depth + 1 : 0;
+      for (let l = 0; l < this.path.length; l++)
+        this.path[l].shouldResetTransform = !0;
+      this.root === this && (this.nodes = new ys());
+    }
+    addEventListener(s, r) {
+      return this.eventHandlers.has(s) || this.eventHandlers.set(s, new ni()), this.eventHandlers.get(s).add(r);
+    }
+    notifyListeners(s, ...r) {
+      const l = this.eventHandlers.get(s);
+      l && l.notify(...r);
+    }
+    hasListeners(s) {
+      return this.eventHandlers.has(s);
+    }
+    /**
+     * Lifecycles
+     */
+    mount(s) {
+      if (this.instance)
+        return;
+      this.isSVG = tn(s) && !ii(s), this.instance = s;
+      const { layoutId: r, layout: l, visualElement: c } = this.options;
+      if (c && !c.current && c.mount(s), this.root.nodes.add(this), this.parent && this.parent.children.add(this), this.root.hasTreeAnimated && (l || r) && (this.isLayoutDirty = !0), t) {
+        let u, f = 0;
+        const h = () => this.root.updateBlockedByResize = !1;
+        A.read(() => {
+          f = window.innerWidth;
+        }), t(s, () => {
+          const d = window.innerWidth;
+          d !== f && (f = d, this.root.updateBlockedByResize = !0, u && u(), u = vs(h, 250), mt.hasAnimatedSinceResize && (mt.hasAnimatedSinceResize = !1, this.nodes.forEach(Ve)));
+        });
+      }
+      r && this.root.registerSharedNode(r, this), this.options.animate !== !1 && c && (r || l) && this.addEventListener("didUpdate", ({ delta: u, hasLayoutChanged: f, hasRelativeLayoutChanged: h, layout: d }) => {
+        if (this.isTreeAnimationBlocked()) {
+          this.target = void 0, this.relativeTarget = void 0;
+          return;
+        }
+        const m = this.options.transition || c.getDefaultTransition() || js, { onLayoutAnimationStart: P, onLayoutAnimationComplete: g } = c.getProps(), p = !this.targetLayout || !En(this.targetLayout, d), y = !f && h;
+        if (this.options.layoutRoot || this.resumeFrom || y || f && (p || !this.currentAnimation)) {
+          this.resumeFrom && (this.resumingFrom = this.resumeFrom, this.resumingFrom.resumingFrom = void 0);
+          const v = {
+            ...si(m, "layout"),
+            onPlay: P,
+            onComplete: g
+          };
+          (c.shouldReduceMotion || this.options.layoutRoot) && (v.delay = 0, v.type = !1), this.startAnimation(v), this.setAnimationOrigin(u, y);
+        } else
+          f || Ve(this), this.isLead() && this.options.onExitComplete && this.options.onExitComplete();
+        this.targetLayout = d;
+      });
+    }
+    unmount() {
+      this.options.layoutId && this.willUpdate(), this.root.nodes.remove(this);
+      const s = this.getStack();
+      s && s.remove(this), this.parent && this.parent.children.delete(this), this.instance = void 0, this.eventHandlers.clear(), tt(this.updateProjection);
+    }
+    // only on the root
+    blockUpdate() {
+      this.updateManuallyBlocked = !0;
+    }
+    unblockUpdate() {
+      this.updateManuallyBlocked = !1;
+    }
+    isUpdateBlocked() {
+      return this.updateManuallyBlocked || this.updateBlockedByResize;
+    }
+    isTreeAnimationBlocked() {
+      return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || !1;
+    }
+    // Note: currently only running on root node
+    startUpdate() {
+      this.isUpdateBlocked() || (this.isUpdating = !0, this.nodes && this.nodes.forEach(Rs), this.animationId++);
+    }
+    getTransformTemplate() {
+      const { visualElement: s } = this.options;
+      return s && s.getProps().transformTemplate;
+    }
+    willUpdate(s = !0) {
+      if (this.root.hasTreeAnimated = !0, this.root.isUpdateBlocked()) {
+        this.options.onExitComplete && this.options.onExitComplete();
+        return;
+      }
+      if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear && Cn(this), !this.root.isUpdating && this.root.startUpdate(), this.isLayoutDirty)
+        return;
+      this.isLayoutDirty = !0;
+      for (let u = 0; u < this.path.length; u++) {
+        const f = this.path[u];
+        f.shouldResetTransform = !0, f.updateScroll("snapshot"), f.options.layoutRoot && f.willUpdate(!1);
+      }
+      const { layoutId: r, layout: l } = this.options;
+      if (r === void 0 && !l)
+        return;
+      const c = this.getTransformTemplate();
+      this.prevTransformTemplateValue = c ? c(this.latestValues, "") : void 0, this.updateSnapshot(), s && this.notifyListeners("willUpdate");
+    }
+    update() {
+      if (this.updateScheduled = !1, this.isUpdateBlocked()) {
+        this.unblockUpdate(), this.clearAllSnapshots(), this.nodes.forEach(Ce);
+        return;
+      }
+      if (this.animationId <= this.animationCommitId) {
+        this.nodes.forEach(Le);
+        return;
+      }
+      this.animationCommitId = this.animationId, this.isUpdating ? (this.isUpdating = !1, this.nodes.forEach(Cs), this.nodes.forEach(Ts), this.nodes.forEach(Ss)) : this.nodes.forEach(Le), this.clearAllSnapshots();
+      const r = on.now();
+      R.delta = rn(0, 1e3 / 60, r - R.timestamp), R.timestamp = r, R.isProcessing = !0, St.update.process(R), St.preRender.process(R), St.render.process(R), R.isProcessing = !1;
+    }
+    didUpdate() {
+      this.updateScheduled || (this.updateScheduled = !0, an.read(this.scheduleUpdate));
+    }
+    clearAllSnapshots() {
+      this.nodes.forEach(As), this.sharedNodes.forEach(bs);
+    }
+    scheduleUpdateProjection() {
+      this.projectionUpdateScheduled || (this.projectionUpdateScheduled = !0, A.preRender(this.updateProjection, !1, !0));
+    }
+    scheduleCheckAfterUnmount() {
+      A.postRender(() => {
+        this.isLayoutDirty ? this.root.didUpdate() : this.root.checkUpdateFailed();
+      });
+    }
+    /**
+     * Update measurements
+     */
+    updateSnapshot() {
+      this.snapshot || !this.instance || (this.snapshot = this.measure(), this.snapshot && !L(this.snapshot.measuredBox.x) && !L(this.snapshot.measuredBox.y) && (this.snapshot = void 0));
+    }
+    updateLayout() {
+      if (!this.instance || (this.updateScroll(), !(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty))
+        return;
+      if (this.resumeFrom && !this.resumeFrom.instance)
+        for (let l = 0; l < this.path.length; l++)
+          this.path[l].updateScroll();
+      const s = this.layout;
+      this.layout = this.measure(!1), this.layoutVersion++, this.layoutCorrected = E(), this.isLayoutDirty = !1, this.projectionDelta = void 0, this.notifyListeners("measure", this.layout.layoutBox);
+      const { visualElement: r } = this.options;
+      r && r.notify("LayoutMeasure", this.layout.layoutBox, s ? s.layoutBox : void 0);
+    }
+    updateScroll(s = "measure") {
+      let r = !!(this.options.layoutScroll && this.instance);
+      if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === s && (r = !1), r && this.instance) {
+        const l = i(this.instance);
+        this.scroll = {
+          animationId: this.root.animationId,
+          phase: s,
+          isRoot: l,
+          offset: n(this.instance),
+          wasRoot: this.scroll ? this.scroll.isRoot : l
+        };
+      }
+    }
+    resetTransform() {
+      if (!o)
+        return;
+      const s = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout, r = this.projectionDelta && !Sn(this.projectionDelta), l = this.getTransformTemplate(), c = l ? l(this.latestValues, "") : void 0, u = c !== this.prevTransformTemplateValue;
+      s && this.instance && (r || $(this.latestValues) || u) && (o(this.instance, c), this.shouldResetTransform = !1, this.scheduleRender());
+    }
+    measure(s = !0) {
+      const r = this.measurePageBox();
+      let l = this.removeElementScroll(r);
+      return s && (l = this.removeTransform(l)), Is(l), {
+        animationId: this.root.animationId,
+        measuredBox: r,
+        layoutBox: l,
+        latestValues: {},
+        source: this.id
+      };
+    }
+    measurePageBox() {
+      const { visualElement: s } = this.options;
+      if (!s)
+        return E();
+      const r = s.measureViewportBox();
+      if (!(this.scroll?.wasRoot || this.path.some(Bs))) {
+        const { scroll: c } = this.root;
+        c && (ot(r.x, c.offset.x), ot(r.y, c.offset.y));
+      }
+      return r;
+    }
+    removeElementScroll(s) {
+      const r = E();
+      if (M(r, s), this.scroll?.wasRoot)
+        return r;
+      for (let l = 0; l < this.path.length; l++) {
+        const c = this.path[l], { scroll: u, options: f } = c;
+        c !== this.root && u && f.layoutScroll && (u.wasRoot && M(r, s), ot(r.x, u.offset.x), ot(r.y, u.offset.y));
+      }
+      return r;
+    }
+    applyTransform(s, r = !1) {
+      const l = E();
+      M(l, s);
+      for (let c = 0; c < this.path.length; c++) {
+        const u = this.path[c];
+        !r && u.options.layoutScroll && u.scroll && u !== u.root && rt(l, {
+          x: -u.scroll.offset.x,
+          y: -u.scroll.offset.y
+        }), $(u.latestValues) && rt(l, u.latestValues);
+      }
+      return $(this.latestValues) && rt(l, this.latestValues), l;
+    }
+    removeTransform(s) {
+      const r = E();
+      M(r, s);
+      for (let l = 0; l < this.path.length; l++) {
+        const c = this.path[l];
+        if (!c.instance || !$(c.latestValues))
+          continue;
+        ne(c.latestValues) && c.updateSnapshot();
+        const u = E(), f = c.measurePageBox();
+        M(u, f), ve(r, c.latestValues, c.snapshot ? c.snapshot.layoutBox : void 0, u);
+      }
+      return $(this.latestValues) && ve(r, this.latestValues), r;
+    }
+    setTargetDelta(s) {
+      this.targetDelta = s, this.root.scheduleUpdateProjection(), this.isProjectionDirty = !0;
+    }
+    setOptions(s) {
+      this.options = {
+        ...this.options,
+        ...s,
+        crossfade: s.crossfade !== void 0 ? s.crossfade : !0
+      };
+    }
+    clearMeasurements() {
+      this.scroll = void 0, this.layout = void 0, this.snapshot = void 0, this.prevTransformTemplateValue = void 0, this.targetDelta = void 0, this.target = void 0, this.isLayoutDirty = !1;
+    }
+    forceRelativeParentToResolveTarget() {
+      this.relativeParent && this.relativeParent.resolvedRelativeTargetAt !== R.timestamp && this.relativeParent.resolveTargetDelta(!0);
+    }
+    resolveTargetDelta(s = !1) {
+      const r = this.getLead();
+      this.isProjectionDirty || (this.isProjectionDirty = r.isProjectionDirty), this.isTransformDirty || (this.isTransformDirty = r.isTransformDirty), this.isSharedProjectionDirty || (this.isSharedProjectionDirty = r.isSharedProjectionDirty);
+      const l = !!this.resumingFrom || this !== r;
+      if (!(s || l && this.isSharedProjectionDirty || this.isProjectionDirty || this.parent?.isProjectionDirty || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize))
+        return;
+      const { layout: u, layoutId: f } = this.options;
+      if (!this.layout || !(u || f))
+        return;
+      this.resolvedRelativeTargetAt = R.timestamp;
+      const h = this.getClosestProjectingParent();
+      h && this.linkedParentVersion !== h.layoutVersion && !h.options.layoutRoot && this.removeRelativeTarget(), !this.targetDelta && !this.relativeTarget && (h && h.layout ? this.createRelativeTarget(h, this.layout.layoutBox, h.layout.layoutBox) : this.removeRelativeTarget()), !(!this.relativeTarget && !this.targetDelta) && (this.target || (this.target = E(), this.targetWithTransforms = E()), this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target ? (this.forceRelativeParentToResolveTarget(), rs(this.target, this.relativeTarget, this.relativeParent.target)) : this.targetDelta ? (this.resumingFrom ? this.target = this.applyTransform(this.layout.layoutBox) : M(this.target, this.layout.layoutBox), oi(this.target, this.targetDelta)) : M(this.target, this.layout.layoutBox), this.attemptToResolveRelativeTarget && (this.attemptToResolveRelativeTarget = !1, h && !!h.resumingFrom == !!this.resumingFrom && !h.options.layoutScroll && h.target && this.animationProgress !== 1 ? this.createRelativeTarget(h, this.target, h.target) : this.relativeParent = this.relativeTarget = void 0));
+    }
+    getClosestProjectingParent() {
+      if (!(!this.parent || ne(this.parent.latestValues) || ri(this.parent.latestValues)))
+        return this.parent.isProjecting() ? this.parent : this.parent.getClosestProjectingParent();
+    }
+    isProjecting() {
+      return !!((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
+    }
+    createRelativeTarget(s, r, l) {
+      this.relativeParent = s, this.linkedParentVersion = s.layoutVersion, this.forceRelativeParentToResolveTarget(), this.relativeTarget = E(), this.relativeTargetOrigin = E(), yt(this.relativeTargetOrigin, r, l), M(this.relativeTarget, this.relativeTargetOrigin);
+    }
+    removeRelativeTarget() {
+      this.relativeParent = this.relativeTarget = void 0;
+    }
+    calcProjection() {
+      const s = this.getLead(), r = !!this.resumingFrom || this !== s;
+      let l = !0;
+      if ((this.isProjectionDirty || this.parent?.isProjectionDirty) && (l = !1), r && (this.isSharedProjectionDirty || this.isTransformDirty) && (l = !1), this.resolvedRelativeTargetAt === R.timestamp && (l = !1), l)
+        return;
+      const { layout: c, layoutId: u } = this.options;
+      if (this.isTreeAnimating = !!(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation), this.isTreeAnimating || (this.targetDelta = this.relativeTarget = void 0), !this.layout || !(c || u))
+        return;
+      M(this.layoutCorrected, this.layout.layoutBox);
+      const f = this.treeScale.x, h = this.treeScale.y;
+      ai(this.layoutCorrected, this.treeScale, this.path, r), s.layout && !s.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1) && (s.target = s.layout.layoutBox, s.targetWithTransforms = E());
+      const { target: d } = s;
+      if (!d) {
+        this.prevProjectionDelta && (this.createProjectionDeltas(), this.scheduleRender());
+        return;
+      }
+      !this.projectionDelta || !this.prevProjectionDelta ? this.createProjectionDeltas() : (fe(this.prevProjectionDelta.x, this.projectionDelta.x), fe(this.prevProjectionDelta.y, this.projectionDelta.y)), J(this.projectionDelta, this.layoutCorrected, d, this.latestValues), (this.treeScale.x !== f || this.treeScale.y !== h || !Se(this.projectionDelta.x, this.prevProjectionDelta.x) || !Se(this.projectionDelta.y, this.prevProjectionDelta.y)) && (this.hasProjected = !0, this.scheduleRender(), this.notifyListeners("projectionUpdate", d));
+    }
+    hide() {
+      this.isVisible = !1;
+    }
+    show() {
+      this.isVisible = !0;
+    }
+    scheduleRender(s = !0) {
+      if (this.options.visualElement?.scheduleRender(), s) {
+        const r = this.getStack();
+        r && r.scheduleRender();
+      }
+      this.resumingFrom && !this.resumingFrom.instance && (this.resumingFrom = void 0);
+    }
+    createProjectionDeltas() {
+      this.prevProjectionDelta = Y(), this.projectionDelta = Y(), this.projectionDeltaWithTransform = Y();
+    }
+    setAnimationOrigin(s, r = !1) {
+      const l = this.snapshot, c = l ? l.latestValues : {}, u = { ...this.latestValues }, f = Y();
+      (!this.relativeParent || !this.relativeParent.options.layoutRoot) && (this.relativeTarget = this.relativeTargetOrigin = void 0), this.attemptToResolveRelativeTarget = !r;
+      const h = E(), d = l ? l.source : void 0, m = this.layout ? this.layout.source : void 0, P = d !== m, g = this.getStack(), p = !g || g.members.length <= 1, y = !!(P && !p && this.options.crossfade === !0 && !this.path.some(ks));
+      this.animationProgress = 0;
+      let v;
+      this.mixTargetDelta = (x) => {
+        const T = x / 1e3;
+        Re(f.x, s.x, T), Re(f.y, s.y, T), this.setTargetDelta(f), this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout && (yt(h, this.layout.layoutBox, this.relativeParent.layout.layoutBox), Ms(this.relativeTarget, this.relativeTargetOrigin, h, T), v && us(this.relativeTarget, v) && (this.isProjectionDirty = !1), v || (v = E()), M(v, this.relativeTarget)), P && (this.animationValues = u, ds(u, c, this.latestValues, T, y, p)), this.root.scheduleUpdateProjection(), this.scheduleRender(), this.animationProgress = T;
+      }, this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
+    }
+    startAnimation(s) {
+      this.notifyListeners("animationStart"), this.currentAnimation?.stop(), this.resumingFrom?.currentAnimation?.stop(), this.pendingAnimation && (tt(this.pendingAnimation), this.pendingAnimation = void 0), this.pendingAnimation = A.update(() => {
+        mt.hasAnimatedSinceResize = !0, this.motionValue || (this.motionValue = li(0)), this.motionValue.jump(0, !1), this.currentAnimation = ci(this.motionValue, [0, 1e3], {
+          ...s,
+          velocity: 0,
+          isSync: !0,
+          onUpdate: (r) => {
+            this.mixTargetDelta(r), s.onUpdate && s.onUpdate(r);
+          },
+          onStop: () => {
+          },
+          onComplete: () => {
+            s.onComplete && s.onComplete(), this.completeAnimation();
+          }
+        }), this.resumingFrom && (this.resumingFrom.currentAnimation = this.currentAnimation), this.pendingAnimation = void 0;
+      });
+    }
+    completeAnimation() {
+      this.resumingFrom && (this.resumingFrom.currentAnimation = void 0, this.resumingFrom.preserveOpacity = void 0);
+      const s = this.getStack();
+      s && s.exitAnimationComplete(), this.resumingFrom = this.currentAnimation = this.animationValues = void 0, this.notifyListeners("animationComplete");
+    }
+    finishAnimation() {
+      this.currentAnimation && (this.mixTargetDelta && this.mixTargetDelta(xs), this.currentAnimation.stop()), this.completeAnimation();
+    }
+    applyTransformsToTarget() {
+      const s = this.getLead();
+      let { targetWithTransforms: r, target: l, layout: c, latestValues: u } = s;
+      if (!(!r || !l || !c)) {
+        if (this !== s && this.layout && c && Vn(this.options.animationType, this.layout.layoutBox, c.layoutBox)) {
+          l = this.target || E();
+          const f = L(this.layout.layoutBox.x);
+          l.x.min = s.target.x.min, l.x.max = l.x.min + f;
+          const h = L(this.layout.layoutBox.y);
+          l.y.min = s.target.y.min, l.y.max = l.y.min + h;
+        }
+        M(r, l), rt(r, u), J(this.projectionDeltaWithTransform, this.layoutCorrected, r, u);
+      }
+    }
+    registerSharedNode(s, r) {
+      this.sharedNodes.has(s) || this.sharedNodes.set(s, new Ps()), this.sharedNodes.get(s).add(r);
+      const c = r.options.initialPromotionConfig;
+      r.promote({
+        transition: c ? c.transition : void 0,
+        preserveFollowOpacity: c && c.shouldPreserveFollowOpacity ? c.shouldPreserveFollowOpacity(r) : void 0
+      });
+    }
+    isLead() {
+      const s = this.getStack();
+      return s ? s.lead === this : !0;
+    }
+    getLead() {
+      const { layoutId: s } = this.options;
+      return s ? this.getStack()?.lead || this : this;
+    }
+    getPrevLead() {
+      const { layoutId: s } = this.options;
+      return s ? this.getStack()?.prevLead : void 0;
+    }
+    getStack() {
+      const { layoutId: s } = this.options;
+      if (s)
+        return this.root.sharedNodes.get(s);
+    }
+    promote({ needsReset: s, transition: r, preserveFollowOpacity: l } = {}) {
+      const c = this.getStack();
+      c && c.promote(this, l), s && (this.projectionDelta = void 0, this.needsReset = !0), r && this.setOptions({ transition: r });
+    }
+    relegate() {
+      const s = this.getStack();
+      return s ? s.relegate(this) : !1;
+    }
+    resetSkewAndRotation() {
+      const { visualElement: s } = this.options;
+      if (!s)
+        return;
+      let r = !1;
+      const { latestValues: l } = s;
+      if ((l.z || l.rotate || l.rotateX || l.rotateY || l.rotateZ || l.skewX || l.skewY) && (r = !0), !r)
+        return;
+      const c = {};
+      l.z && At("z", s, c, this.animationValues);
+      for (let u = 0; u < Dt.length; u++)
+        At(`rotate${Dt[u]}`, s, c, this.animationValues), At(`skew${Dt[u]}`, s, c, this.animationValues);
+      s.render();
+      for (const u in c)
+        s.setStaticValue(u, c[u]), this.animationValues && (this.animationValues[u] = c[u]);
+      s.scheduleRender();
+    }
+    applyProjectionStyles(s, r) {
+      if (!this.instance || this.isSVG)
+        return;
+      if (!this.isVisible) {
+        s.visibility = "hidden";
+        return;
+      }
+      const l = this.getTransformTemplate();
+      if (this.needsReset) {
+        this.needsReset = !1, s.visibility = "", s.opacity = "", s.pointerEvents = dt(r?.pointerEvents) || "", s.transform = l ? l(this.latestValues, "") : "none";
+        return;
+      }
+      const c = this.getLead();
+      if (!this.projectionDelta || !this.layout || !c.target) {
+        this.options.layoutId && (s.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1, s.pointerEvents = dt(r?.pointerEvents) || ""), this.hasProjected && !$(this.latestValues) && (s.transform = l ? l({}, "") : "none", this.hasProjected = !1);
+        return;
+      }
+      s.visibility = "";
+      const u = c.animationValues || c.latestValues;
+      this.applyTransformsToTarget();
+      let f = hs(this.projectionDeltaWithTransform, this.treeScale, u);
+      l && (f = l(u, f)), s.transform = f;
+      const { x: h, y: d } = this.projectionDelta;
+      s.transformOrigin = `${h.origin * 100}% ${d.origin * 100}% 0`, c.animationValues ? s.opacity = c === this ? u.opacity ?? this.latestValues.opacity ?? 1 : this.preserveOpacity ? this.latestValues.opacity : u.opacityExit : s.opacity = c === this ? u.opacity !== void 0 ? u.opacity : "" : u.opacityExit !== void 0 ? u.opacityExit : 0;
+      for (const m in ie) {
+        if (u[m] === void 0)
+          continue;
+        const { correct: P, applyTo: g, isCSSVariable: p } = ie[m], y = f === "none" ? u[m] : P(u[m], c);
+        if (g) {
+          const v = g.length;
+          for (let x = 0; x < v; x++)
+            s[g[x]] = y;
+        } else
+          p ? this.options.visualElement.renderState.vars[m] = y : s[m] = y;
+      }
+      this.options.layoutId && (s.pointerEvents = c === this ? dt(r?.pointerEvents) || "" : "none");
+    }
+    clearSnapshot() {
+      this.resumeFrom = this.snapshot = void 0;
+    }
+    // Only run on root
+    resetTree() {
+      this.root.nodes.forEach((s) => s.currentAnimation?.stop()), this.root.nodes.forEach(Ce), this.root.sharedNodes.clear();
+    }
+  };
+}
+function Ts(t) {
+  t.updateLayout();
+}
+function Ss(t) {
+  const e = t.resumeFrom?.snapshot || t.snapshot;
+  if (t.isLead() && t.layout && e && t.hasListeners("didUpdate")) {
+    const { layoutBox: n, measuredBox: i } = t.layout, { animationType: o } = t.options, a = e.source !== t.layout.source;
+    o === "size" ? I((u) => {
+      const f = a ? e.measuredBox[u] : e.layoutBox[u], h = L(f);
+      f.min = n[u].min, f.max = f.min + h;
+    }) : Vn(o, e.layoutBox, n) && I((u) => {
+      const f = a ? e.measuredBox[u] : e.layoutBox[u], h = L(n[u]);
+      f.max = f.min + h, t.relativeTarget && !t.currentAnimation && (t.isProjectionDirty = !0, t.relativeTarget[u].max = t.relativeTarget[u].min + h);
+    });
+    const s = Y();
+    J(s, n, e.layoutBox);
+    const r = Y();
+    a ? J(r, t.applyTransform(i, !0), e.measuredBox) : J(r, n, e.layoutBox);
+    const l = !Sn(s);
+    let c = !1;
+    if (!t.resumeFrom) {
+      const u = t.getClosestProjectingParent();
+      if (u && !u.resumeFrom) {
+        const { snapshot: f, layout: h } = u;
+        if (f && h) {
+          const d = E();
+          yt(d, e.layoutBox, f.layoutBox);
+          const m = E();
+          yt(m, n, h.layoutBox), En(d, m) || (c = !0), u.options.layoutRoot && (t.relativeTarget = m, t.relativeTargetOrigin = d, t.relativeParent = u);
+        }
+      }
+    }
+    t.notifyListeners("didUpdate", {
+      layout: n,
+      snapshot: e,
+      delta: r,
+      layoutDelta: s,
+      hasLayoutChanged: l,
+      hasRelativeLayoutChanged: c
+    });
+  } else if (t.isLead()) {
+    const { onExitComplete: n } = t.options;
+    n && n();
+  }
+  t.options.transition = void 0;
+}
+function Es(t) {
+  t.parent && (t.isProjecting() || (t.isProjectionDirty = t.parent.isProjectionDirty), t.isSharedProjectionDirty || (t.isSharedProjectionDirty = !!(t.isProjectionDirty || t.parent.isProjectionDirty || t.parent.isSharedProjectionDirty)), t.isTransformDirty || (t.isTransformDirty = t.parent.isTransformDirty));
+}
+function Ds(t) {
+  t.isProjectionDirty = t.isSharedProjectionDirty = t.isTransformDirty = !1;
+}
+function As(t) {
+  t.clearSnapshot();
+}
+function Ce(t) {
+  t.clearMeasurements();
+}
+function Le(t) {
+  t.isLayoutDirty = !1;
+}
+function Cs(t) {
+  const { visualElement: e } = t.options;
+  e && e.getProps().onBeforeLayoutMeasure && e.notify("BeforeLayoutMeasure"), t.resetTransform();
+}
+function Ve(t) {
+  t.finishAnimation(), t.targetDelta = t.relativeTarget = t.target = void 0, t.isProjectionDirty = !0;
+}
+function Ls(t) {
+  t.resolveTargetDelta();
+}
+function Vs(t) {
+  t.calcProjection();
+}
+function Rs(t) {
+  t.resetSkewAndRotation();
+}
+function bs(t) {
+  t.removeLeadSnapshot();
+}
+function Re(t, e, n) {
+  t.translate = D(e.translate, 0, n), t.scale = D(e.scale, 1, n), t.origin = e.origin, t.originPoint = e.originPoint;
+}
+function be(t, e, n, i) {
+  t.min = D(e.min, n.min, i), t.max = D(e.max, n.max, i);
+}
+function Ms(t, e, n, i) {
+  be(t.x, e.x, n.x, i), be(t.y, e.y, n.y, i);
+}
+function ks(t) {
+  return t.animationValues && t.animationValues.opacityExit !== void 0;
+}
+const js = {
+  duration: 0.45,
+  ease: [0.4, 0, 0.1, 1]
+}, Me = (t) => typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(t), ke = Me("applewebkit/") && !Me("chrome/") ? Math.round : K;
+function je(t) {
+  t.min = ke(t.min), t.max = ke(t.max);
+}
+function Is(t) {
+  je(t.x), je(t.y);
+}
+function Vn(t, e, n) {
+  return t === "position" || t === "preserve-aspect" && !os(Te(e), Te(n), 0.2);
+}
+function Bs(t) {
+  return t !== t.root && t.scroll?.wasRoot;
+}
+const Os = Ln({
+  attachResizeListener: (t, e) => et(t, "resize", e),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body?.scrollLeft || 0,
+    y: document.documentElement.scrollTop || document.body?.scrollTop || 0
+  }),
+  checkIsScrollRoot: () => !0
+}), Ct = {
+  current: void 0
+}, Rn = Ln({
+  measureScroll: (t) => ({
+    x: t.scrollLeft,
+    y: t.scrollTop
+  }),
+  defaultParent: () => {
+    if (!Ct.current) {
+      const t = new Os({});
+      t.mount(window), t.setOptions({ layoutScroll: !0 }), Ct.current = t;
+    }
+    return Ct.current;
+  },
+  resetTransform: (t, e) => {
+    t.style.transform = e !== void 0 ? e : "none";
+  },
+  checkIsScrollRoot: (t) => window.getComputedStyle(t).position === "fixed"
+});
+function Ie(t, e) {
+  if (typeof t == "function")
+    return t(e);
+  t != null && (t.current = e);
+}
+function Fs(...t) {
+  return (e) => {
+    let n = !1;
+    const i = t.map((o) => {
+      const a = Ie(o, e);
+      return !n && typeof a == "function" && (n = !0), a;
+    });
+    if (n)
+      return () => {
+        for (let o = 0; o < i.length; o++) {
+          const a = i[o];
+          typeof a == "function" ? a() : Ie(t[o], null);
+        }
+      };
+  };
+}
+function Us(...t) {
+  return Pt.useCallback(Fs(...t), t);
+}
+class Ws extends Pt.Component {
+  getSnapshotBeforeUpdate(e) {
+    const n = this.props.childRef.current;
+    if (n && e.isPresent && !this.props.isPresent && this.props.pop !== !1) {
+      const i = n.offsetParent, o = Ot(i) && i.offsetWidth || 0, a = Ot(i) && i.offsetHeight || 0, s = this.props.sizeRef.current;
+      s.height = n.offsetHeight || 0, s.width = n.offsetWidth || 0, s.top = n.offsetTop, s.left = n.offsetLeft, s.right = o - s.width - s.left, s.bottom = a - s.height - s.top;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function Hs({ children: t, isPresent: e, anchorX: n, anchorY: i, root: o, pop: a }) {
+  const s = Ht(), r = j(null), l = j({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0
+  }), { nonce: c } = C($t), u = t.props?.ref ?? t?.ref, f = Us(r, u);
+  return Nt(() => {
+    const { width: h, height: d, top: m, left: P, right: g, bottom: p } = l.current;
+    if (e || a === !1 || !r.current || !h || !d)
+      return;
+    const y = n === "left" ? `left: ${P}` : `right: ${g}`, v = i === "bottom" ? `bottom: ${p}` : `top: ${m}`;
+    r.current.dataset.motionPopId = s;
+    const x = document.createElement("style");
+    c && (x.nonce = c);
+    const T = o ?? document.head;
+    return T.appendChild(x), x.sheet && x.sheet.insertRule(`
+          [data-motion-pop-id="${s}"] {
+            position: absolute !important;
+            width: ${h}px !important;
+            height: ${d}px !important;
+            ${y}px !important;
+            ${v}px !important;
+          }
+        `), () => {
+      T.contains(x) && T.removeChild(x);
+    };
+  }, [e]), N(Ws, { isPresent: e, childRef: r, sizeRef: l, pop: a, children: a === !1 ? t : Pt.cloneElement(t, { ref: f }) });
+}
+const Ns = ({ children: t, initial: e, isPresent: n, onExitComplete: i, custom: o, presenceAffectsLayout: a, mode: s, anchorX: r, anchorY: l, root: c }) => {
+  const u = Xt(zs), f = Ht();
+  let h = !0, d = z(() => (h = !1, {
+    id: f,
+    initial: e,
+    isPresent: n,
+    custom: o,
+    onExitComplete: (m) => {
+      u.set(m, !0);
+      for (const P of u.values())
+        if (!P)
+          return;
+      i && i();
+    },
+    register: (m) => (u.set(m, !1), () => u.delete(m))
+  }), [n, u, i]);
+  return a && h && (d = { ...d }), z(() => {
+    u.forEach((m, P) => u.set(P, !1));
+  }, [n]), Pt.useEffect(() => {
+    !n && !u.size && i && i();
+  }, [n]), t = N(Hs, { pop: s === "popLayout", isPresent: n, anchorX: r, anchorY: l, root: c, children: t }), N(xt.Provider, { value: d, children: t });
+};
+function zs() {
+  return /* @__PURE__ */ new Map();
+}
+function bn(t = !0) {
+  const e = C(xt);
+  if (e === null)
+    return [!0, null];
+  const { isPresent: n, onExitComplete: i, register: o } = e, a = Ht();
+  Wt(() => {
+    if (t)
+      return o(a);
+  }, [t]);
+  const s = qe(() => t && i && i(a), [a, i, t]);
+  return !n && i ? [!1, s] : [!0];
+}
+const at = (t) => t.key || "";
+function Be(t) {
+  const e = [];
+  return _n.forEach(t, (n) => {
+    Kn(n) && e.push(n);
+  }), e;
+}
+const ir = ({ children: t, custom: e, initial: n = !0, onExitComplete: i, presenceAffectsLayout: o = !0, mode: a = "sync", propagate: s = !1, anchorX: r = "left", anchorY: l = "top", root: c }) => {
+  const [u, f] = bn(s), h = z(() => Be(t), [t]), d = s && !u ? [] : h.map(at), m = j(!0), P = j(h), g = Xt(() => /* @__PURE__ */ new Map()), p = j(/* @__PURE__ */ new Set()), [y, v] = Qt(h), [x, T] = Qt(h);
+  dn(() => {
+    m.current = !1, P.current = h;
+    for (let V = 0; V < x.length; V++) {
+      const w = at(x[V]);
+      d.includes(w) ? (g.delete(w), p.current.delete(w)) : g.get(w) !== !0 && g.set(w, !1);
+    }
+  }, [x, d.length, d.join("-")]);
+  const F = [];
+  if (h !== y) {
+    let V = [...h];
+    for (let w = 0; w < x.length; w++) {
+      const B = x[w], O = at(B);
+      d.includes(O) || (V.splice(w, 0, B), F.push(B));
+    }
+    return a === "wait" && F.length && (V = F), T(Be(V)), v(h), null;
+  }
+  process.env.NODE_ENV !== "production" && a === "wait" && x.length > 1 && console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+  const { forceRender: st } = C(Yt);
+  return N($n, { children: x.map((V) => {
+    const w = at(V), B = s && !u ? !1 : h === x || d.includes(w), O = () => {
+      if (p.current.has(w))
+        return;
+      if (p.current.add(w), g.has(w))
+        g.set(w, !0);
+      else
+        return;
+      let q = !0;
+      g.forEach((Tt) => {
+        Tt || (q = !1);
+      }), q && (st?.(), T(P.current), s && f?.(), i && i());
+    };
+    return N(Ns, { isPresent: B, initial: !m.current || n ? void 0 : !1, custom: e, presenceAffectsLayout: o, mode: a, root: c, onExitComplete: B ? void 0 : O, anchorX: r, anchorY: l, children: V }, w);
+  }) });
+}, Mn = nt({ strict: !1 }), Oe = {
+  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"]
+};
+let Fe = !1;
+function Gs() {
+  if (Fe)
+    return;
+  const t = {};
+  for (const e in Oe)
+    t[e] = {
+      isEnabled: (n) => Oe[e].some((i) => !!n[i])
+    };
+  ln(t), Fe = !0;
+}
+function kn() {
+  return Gs(), hi();
+}
+function $s(t) {
+  const e = kn();
+  for (const n in t)
+    e[n] = {
+      ...e[n],
+      ...t[n]
+    };
+  ln(e);
+}
+const Xs = /* @__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",
+  "propagate",
+  "ignoreStrict",
+  "viewport"
+]);
+function vt(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || Xs.has(t);
+}
+let jn = (t) => !vt(t);
+function Ys(t) {
+  typeof t == "function" && (jn = (e) => e.startsWith("on") ? !vt(e) : t(e));
+}
+try {
+  Ys(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function _s(t, e, n) {
+  const i = {};
+  for (const o in t)
+    o === "values" && typeof t.values == "object" || (jn(o) || n === !0 && vt(o) || !e && !vt(o) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && o.startsWith("onDrag")) && (i[o] = t[o]);
+  return i;
+}
+const wt = /* @__PURE__ */ nt({});
+function Ks(t, e) {
+  if (cn(t)) {
+    const { initial: n, animate: i } = t;
+    return {
+      initial: n === !1 || pt(n) ? n : void 0,
+      animate: pt(i) ? i : void 0
+    };
+  }
+  return t.inherit !== !1 ? e : {};
+}
+function qs(t) {
+  const { initial: e, animate: n } = Ks(t, C(wt));
+  return z(() => ({ initial: e, animate: n }), [Ue(e), Ue(n)]);
+}
+function Ue(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+const Kt = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+function In(t, e, n) {
+  for (const i in e)
+    !Gt(e[i]) && !fi(i, n) && (t[i] = e[i]);
+}
+function Zs({ transformTemplate: t }, e) {
+  return z(() => {
+    const n = Kt();
+    return di(n, e, t), Object.assign({}, n.vars, n.style);
+  }, [e]);
+}
+function Js(t, e) {
+  const n = t.style || {}, i = {};
+  return In(i, n, t), Object.assign(i, Zs(t, e)), i;
+}
+function Qs(t, e) {
+  const n = {}, i = Js(t, e);
+  return t.drag && t.dragListener !== !1 && (n.draggable = !1, i.userSelect = i.WebkitUserSelect = i.WebkitTouchCallout = "none", i.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 = i, n;
+}
+const Bn = () => ({
+  ...Kt(),
+  attrs: {}
+});
+function to(t, e, n, i) {
+  const o = z(() => {
+    const a = Bn();
+    return mi(a, e, pi(i), t.transformTemplate, t.style), {
+      ...a.attrs,
+      style: { ...a.style }
+    };
+  }, [e]);
+  if (t.style) {
+    const a = {};
+    In(a, t.style, t), o.style = { ...a, ...o.style };
+  }
+  return o;
+}
+const eo = [
+  "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 qt(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
+       */
+      !!(eo.indexOf(t) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(t))
+    )
+  );
+}
+function no(t, e, n, { latestValues: i }, o, a = !1, s) {
+  const l = (s ?? qt(t) ? to : Qs)(e, i, o, t), c = _s(e, typeof t == "string", a), u = t !== Ze ? { ...c, ...l, ref: n } : {}, { children: f } = e, h = z(() => Gt(f) ? f.get() : f, [f]);
+  return qn(t, {
+    ...u,
+    children: h
+  });
+}
+function io({ scrapeMotionValuesFromProps: t, createRenderState: e }, n, i, o) {
+  return {
+    latestValues: so(n, i, o, t),
+    renderState: e()
+  };
+}
+function so(t, e, n, i) {
+  const o = {}, a = i(t, {});
+  for (const h in a)
+    o[h] = dt(a[h]);
+  let { initial: s, animate: r } = t;
+  const l = cn(t), c = gi(t);
+  e && c && !l && t.inherit !== !1 && (s === void 0 && (s = e.initial), r === void 0 && (r = e.animate));
+  let u = n ? n.initial === !1 : !1;
+  u = u || s === !1;
+  const f = u ? r : s;
+  if (f && typeof f != "boolean" && !zt(f)) {
+    const h = Array.isArray(f) ? f : [f];
+    for (let d = 0; d < h.length; d++) {
+      const m = yi(t, h[d]);
+      if (m) {
+        const { transitionEnd: P, transition: g, ...p } = m;
+        for (const y in p) {
+          let v = p[y];
+          if (Array.isArray(v)) {
+            const x = u ? v.length - 1 : 0;
+            v = v[x];
+          }
+          v !== null && (o[y] = v);
+        }
+        for (const y in P)
+          o[y] = P[y];
+      }
+    }
+  }
+  return o;
+}
+const On = (t) => (e, n) => {
+  const i = C(wt), o = C(xt), a = () => io(t, e, i, o);
+  return n ? a() : Xt(a);
+}, oo = /* @__PURE__ */ On({
+  scrapeMotionValuesFromProps: vi,
+  createRenderState: Kt
+}), ro = /* @__PURE__ */ On({
+  scrapeMotionValuesFromProps: Pi,
+  createRenderState: Bn
+}), ao = /* @__PURE__ */ Symbol.for("motionComponentSymbol");
+function lo(t, e, n) {
+  const i = j(n);
+  Nt(() => {
+    i.current = n;
+  });
+  const o = j(null);
+  return qe((a) => {
+    a && t.onMount?.(a), e && (a ? e.mount(a) : e.unmount());
+    const s = i.current;
+    if (typeof s == "function")
+      if (a) {
+        const r = s(a);
+        typeof r == "function" && (o.current = r);
+      } else o.current ? (o.current(), o.current = null) : s(a);
+    else s && (s.current = a);
+  }, [e]);
+}
+const Fn = nt({});
+function X(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+function co(t, e, n, i, o, a) {
+  const { visualElement: s } = C(wt), r = C(Mn), l = C(xt), c = C($t), u = c.reducedMotion, f = c.skipAnimations, h = j(null), d = j(!1);
+  i = i || r.renderer, !h.current && i && (h.current = i(t, {
+    visualState: e,
+    parent: s,
+    props: n,
+    presenceContext: l,
+    blockInitialAnimation: l ? l.initial === !1 : !1,
+    reducedMotionConfig: u,
+    skipAnimations: f,
+    isSVG: a
+  }), d.current && h.current && (h.current.manuallyAnimateOnMount = !0));
+  const m = h.current, P = C(Fn);
+  m && !m.projection && o && (m.type === "html" || m.type === "svg") && uo(h.current, n, o, P);
+  const g = j(!1);
+  Nt(() => {
+    m && g.current && m.update(n, l);
+  });
+  const p = n[xi], y = j(!!p && !window.MotionHandoffIsComplete?.(p) && window.MotionHasOptimisedAnimation?.(p));
+  return dn(() => {
+    d.current = !0, m && (g.current = !0, window.MotionIsMounted = !0, m.updateFeatures(), m.scheduleRenderMicrotask(), y.current && m.animationState && m.animationState.animateChanges());
+  }), Wt(() => {
+    m && (!y.current && m.animationState && m.animationState.animateChanges(), y.current && (queueMicrotask(() => {
+      window.MotionHandoffMarkAsComplete?.(p);
+    }), y.current = !1), m.enteringChildren = void 0);
+  }), m;
+}
+function uo(t, e, n, i) {
+  const { layoutId: o, layout: a, drag: s, dragConstraints: r, layoutScroll: l, layoutRoot: c, layoutCrossfade: u } = e;
+  t.projection = new n(t.latestValues, e["data-framer-portal-id"] ? void 0 : Un(t.parent)), t.projection.setOptions({
+    layoutId: o,
+    layout: a,
+    alwaysMeasureLayout: !!s || r && X(r),
+    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 a == "string" ? a : "both",
+    initialPromotionConfig: i,
+    crossfade: u,
+    layoutScroll: l,
+    layoutRoot: c
+  });
+}
+function Un(t) {
+  if (t)
+    return t.options.allowProjection !== !1 ? t.projection : Un(t.parent);
+}
+function Lt(t, { forwardMotionProps: e = !1, type: n } = {}, i, o) {
+  i && $s(i);
+  const a = n ? n === "svg" : qt(t), s = a ? ro : oo;
+  function r(c, u) {
+    let f;
+    const h = {
+      ...C($t),
+      ...c,
+      layoutId: ho(c)
+    }, { isStatic: d } = h, m = qs(c), P = s(c, d);
+    if (!d && fn) {
+      fo(h, i);
+      const g = mo(h);
+      f = g.MeasureLayout, m.visualElement = co(t, P, h, o, g.ProjectionNode, a);
+    }
+    return Xn(wt.Provider, { value: m, children: [f && m.visualElement ? N(f, { visualElement: m.visualElement, ...h }) : null, no(t, c, lo(P, m.visualElement, u), P, d, e, a)] });
+  }
+  r.displayName = `motion.${typeof t == "string" ? t : `create(${t.displayName ?? t.name ?? ""})`}`;
+  const l = Zn(r);
+  return l[ao] = t, l;
+}
+function ho({ layoutId: t }) {
+  const e = C(Yt).id;
+  return e && t !== void 0 ? e + "-" + t : t;
+}
+function fo(t, e) {
+  const n = C(Mn).strict;
+  if (process.env.NODE_ENV !== "production" && e && n) {
+    const i = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? wi(!1, i, "lazy-strict-mode") : un(!1, i, "lazy-strict-mode");
+  }
+}
+function mo(t) {
+  const e = kn(), { drag: n, layout: i } = e;
+  if (!n && !i)
+    return {};
+  const o = { ...n, ...i };
+  return {
+    MeasureLayout: n?.isEnabled(t) || i?.isEnabled(t) ? o.MeasureLayout : void 0,
+    ProjectionNode: o.ProjectionNode
+  };
+}
+function po(t, e) {
+  if (typeof Proxy > "u")
+    return Lt;
+  const n = /* @__PURE__ */ new Map(), i = (a, s) => Lt(a, s, t, e), o = (a, s) => (process.env.NODE_ENV !== "production" && Ti(!1, "motion() is deprecated. Use motion.create() instead."), i(a, s));
+  return new Proxy(o, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: (a, s) => s === "create" ? i : (n.has(s) || n.set(s, Lt(s, void 0, t, e)), n.get(s))
+  });
+}
+const go = (t, e) => e.isSVG ?? qt(t) ? new Si(e) : new Ei(e, {
+  allowProjection: t !== Ze
+});
+class yo extends U {
+  /**
+   * 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 = Qi(e));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: e } = this.node.getProps();
+    zt(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() {
+    this.node.animationState.reset(), this.unmountControls?.();
+  }
+}
+let vo = 0;
+class Po extends U {
+  constructor() {
+    super(...arguments), this.id = vo++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: e, onExitComplete: n } = this.node.presenceContext, { isPresent: i } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || e === i)
+      return;
+    const o = this.node.animationState.setActive("exit", !e);
+    n && !e && o.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 xo = {
+  animation: {
+    Feature: yo
+  },
+  exit: {
+    Feature: Po
+  }
+};
+function it(t) {
+  return {
+    point: {
+      x: t.pageX,
+      y: t.pageY
+    }
+  };
+}
+const wo = (t) => (e) => _t(e) && t(e, it(e));
+function Q(t, e, n, i) {
+  return et(t, e, wo(n), i);
+}
+const Wn = ({ current: t }) => t ? t.ownerDocument.defaultView : null, We = (t, e) => Math.abs(t - e);
+function To(t, e) {
+  const n = We(t.x, e.x), i = We(t.y, e.y);
+  return Math.sqrt(n ** 2 + i ** 2);
+}
+const He = /* @__PURE__ */ new Set(["auto", "scroll"]);
+class Hn {
+  constructor(e, n, { transformPagePoint: i, contextWindow: o = window, dragSnapToOrigin: a = !1, distanceThreshold: s = 3, element: r } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = /* @__PURE__ */ new Map(), this.removeScrollListeners = null, this.onElementScroll = (d) => {
+      this.handleScroll(d.target);
+    }, this.onWindowScroll = () => {
+      this.handleScroll(window);
+    }, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const d = Rt(this.lastMoveEventInfo, this.history), m = this.startEvent !== null, P = To(d.offset, { x: 0, y: 0 }) >= this.distanceThreshold;
+      if (!m && !P)
+        return;
+      const { point: g } = d, { timestamp: p } = R;
+      this.history.push({ ...g, timestamp: p });
+      const { onStart: y, onMove: v } = this.handlers;
+      m || (y && y(this.lastMoveEvent, d), this.startEvent = this.lastMoveEvent), v && v(this.lastMoveEvent, d);
+    }, this.handlePointerMove = (d, m) => {
+      this.lastMoveEvent = d, this.lastMoveEventInfo = Vt(m, this.transformPagePoint), A.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (d, m) => {
+      this.end();
+      const { onEnd: P, onSessionEnd: g, resumeAnimation: p } = this.handlers;
+      if ((this.dragSnapToOrigin || !this.startEvent) && p && p(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const y = Rt(d.type === "pointercancel" ? this.lastMoveEventInfo : Vt(m, this.transformPagePoint), this.history);
+      this.startEvent && P && P(d, y), g && g(d, y);
+    }, !_t(e))
+      return;
+    this.dragSnapToOrigin = a, this.handlers = n, this.transformPagePoint = i, this.distanceThreshold = s, this.contextWindow = o || window;
+    const l = it(e), c = Vt(l, this.transformPagePoint), { point: u } = c, { timestamp: f } = R;
+    this.history = [{ ...u, timestamp: f }];
+    const { onSessionStart: h } = n;
+    h && h(e, Rt(c, this.history)), this.removeListeners = hn(Q(this.contextWindow, "pointermove", this.handlePointerMove), Q(this.contextWindow, "pointerup", this.handlePointerUp), Q(this.contextWindow, "pointercancel", this.handlePointerUp)), r && this.startScrollTracking(r);
+  }
+  /**
+   * Start tracking scroll on ancestors and window.
+   */
+  startScrollTracking(e) {
+    let n = e.parentElement;
+    for (; n; ) {
+      const i = getComputedStyle(n);
+      (He.has(i.overflowX) || He.has(i.overflowY)) && this.scrollPositions.set(n, {
+        x: n.scrollLeft,
+        y: n.scrollTop
+      }), n = n.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    }), window.addEventListener("scroll", this.onElementScroll, {
+      capture: !0
+    }), window.addEventListener("scroll", this.onWindowScroll), this.removeScrollListeners = () => {
+      window.removeEventListener("scroll", this.onElementScroll, {
+        capture: !0
+      }), window.removeEventListener("scroll", this.onWindowScroll);
+    };
+  }
+  /**
+   * Handle scroll compensation during drag.
+   *
+   * For element scroll: adjusts history origin since pageX/pageY doesn't change.
+   * For window scroll: adjusts lastMoveEventInfo since pageX/pageY would change.
+   */
+  handleScroll(e) {
+    const n = this.scrollPositions.get(e);
+    if (!n)
+      return;
+    const i = e === window, o = i ? { x: window.scrollX, y: window.scrollY } : {
+      x: e.scrollLeft,
+      y: e.scrollTop
+    }, a = { x: o.x - n.x, y: o.y - n.y };
+    a.x === 0 && a.y === 0 || (i ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += a.x, this.lastMoveEventInfo.point.y += a.y) : this.history.length > 0 && (this.history[0].x -= a.x, this.history[0].y -= a.y), this.scrollPositions.set(e, o), A.update(this.updatePoint, !0));
+  }
+  updateHandlers(e) {
+    this.handlers = e;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), this.removeScrollListeners && this.removeScrollListeners(), this.scrollPositions.clear(), tt(this.updatePoint);
+  }
+}
+function Vt(t, e) {
+  return e ? { point: e(t.point) } : t;
+}
+function Ne(t, e) {
+  return { x: t.x - e.x, y: t.y - e.y };
+}
+function Rt({ point: t }, e) {
+  return {
+    point: t,
+    delta: Ne(t, Nn(e)),
+    offset: Ne(t, So(e)),
+    velocity: Eo(e, 0.1)
+  };
+}
+function So(t) {
+  return t[0];
+}
+function Nn(t) {
+  return t[t.length - 1];
+}
+function Eo(t, e) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  let n = t.length - 1, i = null;
+  const o = Nn(t);
+  for (; n >= 0 && (i = t[n], !(o.timestamp - i.timestamp > se(e))); )
+    n--;
+  if (!i)
+    return { x: 0, y: 0 };
+  i === t[0] && t.length > 2 && o.timestamp - i.timestamp > se(e) * 2 && (i = t[1]);
+  const a = Di(o.timestamp - i.timestamp);
+  if (a === 0)
+    return { x: 0, y: 0 };
+  const s = {
+    x: (o.x - i.x) / a,
+    y: (o.y - i.y) / a
+  };
+  return s.x === 1 / 0 && (s.x = 0), s.y === 1 / 0 && (s.y = 0), s;
+}
+function Do(t, { min: e, max: n }, i) {
+  return e !== void 0 && t < e ? t = i ? D(e, t, i.min) : Math.max(t, e) : n !== void 0 && t > n && (t = i ? D(n, t, i.max) : Math.min(t, n)), t;
+}
+function ze(t, e, n) {
+  return {
+    min: e !== void 0 ? t.min + e : void 0,
+    max: n !== void 0 ? t.max + n - (t.max - t.min) : void 0
+  };
+}
+function Ao(t, { top: e, left: n, bottom: i, right: o }) {
+  return {
+    x: ze(t.x, n, o),
+    y: ze(t.y, e, i)
+  };
+}
+function Ge(t, e) {
+  let n = e.min - t.min, i = e.max - t.max;
+  return e.max - e.min < t.max - t.min && ([n, i] = [i, n]), { min: n, max: i };
+}
+function Co(t, e) {
+  return {
+    x: Ge(t.x, e.x),
+    y: Ge(t.y, e.y)
+  };
+}
+function Lo(t, e) {
+  let n = 0.5;
+  const i = L(t), o = L(e);
+  return o > i ? n = jt(e.min, e.max - i, t.min) : i > o && (n = jt(t.min, t.max - o, e.min)), rn(0, 1, n);
+}
+function Vo(t, e) {
+  const n = {};
+  return e.min !== void 0 && (n.min = e.min - t.min), e.max !== void 0 && (n.max = e.max - t.min), n;
+}
+const Ft = 0.35;
+function Ro(t = Ft) {
+  return t === !1 ? t = 0 : t === !0 && (t = Ft), {
+    x: $e(t, "left", "right"),
+    y: $e(t, "top", "bottom")
+  };
+}
+function $e(t, e, n) {
+  return {
+    min: Xe(t, e),
+    max: Xe(t, n)
+  };
+}
+function Xe(t, e) {
+  return typeof t == "number" ? t : t[e] || 0;
+}
+const bo = /* @__PURE__ */ new WeakMap();
+class Mo {
+  constructor(e) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = E(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = e;
+  }
+  start(e, { snapToCursor: n = !1, distanceThreshold: i } = {}) {
+    const { presenceContext: o } = this.visualElement;
+    if (o && o.isPresent === !1)
+      return;
+    const a = (f) => {
+      n && this.snapToCursor(it(f).point), this.stopAnimation();
+    }, s = (f, h) => {
+      const { drag: d, dragPropagation: m, onDragStart: P } = this.getProps();
+      if (d && !m && (this.openDragLock && this.openDragLock(), this.openDragLock = Mi(d), !this.openDragLock))
+        return;
+      this.latestPointerEvent = f, this.latestPanInfo = h, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), I((p) => {
+        let y = this.getAxisMotionValue(p).get() || 0;
+        if (gt.test(y)) {
+          const { projection: v } = this.visualElement;
+          if (v && v.layout) {
+            const x = v.layout.layoutBox[p];
+            x && (y = L(x) * (parseFloat(y) / 100));
+          }
+        }
+        this.originPoint[p] = y;
+      }), P && A.update(() => P(f, h), !1, !0), oe(this.visualElement, "transform");
+      const { animationState: g } = this.visualElement;
+      g && g.setActive("whileDrag", !0);
+    }, r = (f, h) => {
+      this.latestPointerEvent = f, this.latestPanInfo = h;
+      const { dragPropagation: d, dragDirectionLock: m, onDirectionLock: P, onDrag: g } = this.getProps();
+      if (!d && !this.openDragLock)
+        return;
+      const { offset: p } = h;
+      if (m && this.currentDirection === null) {
+        this.currentDirection = jo(p), this.currentDirection !== null && P && P(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", h.point, p), this.updateAxis("y", h.point, p), this.visualElement.render(), g && A.update(() => g(f, h), !1, !0);
+    }, l = (f, h) => {
+      this.latestPointerEvent = f, this.latestPanInfo = h, this.stop(f, h), this.latestPointerEvent = null, this.latestPanInfo = null;
+    }, c = () => {
+      const { dragSnapToOrigin: f } = this.getProps();
+      (f || this.constraints) && this.startAnimation({ x: 0, y: 0 });
+    }, { dragSnapToOrigin: u } = this.getProps();
+    this.panSession = new Hn(e, {
+      onSessionStart: a,
+      onStart: s,
+      onMove: r,
+      onSessionEnd: l,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: u,
+      distanceThreshold: i,
+      contextWindow: Wn(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+   * @internal
+   */
+  stop(e, n) {
+    const i = e || this.latestPointerEvent, o = n || this.latestPanInfo, a = this.isDragging;
+    if (this.cancel(), !a || !o || !i)
+      return;
+    const { velocity: s } = o;
+    this.startAnimation(s);
+    const { onDragEnd: r } = this.getProps();
+    r && A.postRender(() => r(i, o));
+  }
+  /**
+   * @internal
+   */
+  cancel() {
+    this.isDragging = !1;
+    const { projection: e, animationState: n } = this.visualElement;
+    e && (e.isAnimationBlocked = !1), this.endPanSession();
+    const { dragPropagation: i } = this.getProps();
+    !i && this.openDragLock && (this.openDragLock(), this.openDragLock = null), n && n.setActive("whileDrag", !1);
+  }
+  /**
+   * Clean up the pan session without modifying other drag state.
+   * This is used during unmount to ensure event listeners are removed
+   * without affecting projection animations or drag locks.
+   * @internal
+   */
+  endPanSession() {
+    this.panSession && this.panSession.end(), this.panSession = void 0;
+  }
+  updateAxis(e, n, i) {
+    const { drag: o } = this.getProps();
+    if (!i || !lt(e, o, this.currentDirection))
+      return;
+    const a = this.getAxisMotionValue(e);
+    let s = this.originPoint[e] + i[e];
+    this.constraints && this.constraints[e] && (s = Do(s, this.constraints[e], this.elastic[e])), a.set(s);
+  }
+  resolveConstraints() {
+    const { dragConstraints: e, dragElastic: n } = this.getProps(), i = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection?.layout, o = this.constraints;
+    e && X(e) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : e && i ? this.constraints = Ao(i.layoutBox, e) : this.constraints = !1, this.elastic = Ro(n), o !== this.constraints && !X(e) && i && this.constraints && !this.hasMutatedConstraints && I((a) => {
+      this.constraints !== !1 && this.getAxisMotionValue(a) && (this.constraints[a] = Vo(i.layoutBox[a], this.constraints[a]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: e, onMeasureDragConstraints: n } = this.getProps();
+    if (!e || !X(e))
+      return !1;
+    const i = e.current;
+    un(i !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection: o } = this.visualElement;
+    if (!o || !o.layout)
+      return !1;
+    const a = Ai(i, o.root, this.visualElement.getTransformPagePoint());
+    let s = Co(o.layout.layoutBox, a);
+    if (n) {
+      const r = n(Ci(s));
+      this.hasMutatedConstraints = !!r, r && (s = Li(r));
+    }
+    return s;
+  }
+  startAnimation(e) {
+    const { drag: n, dragMomentum: i, dragElastic: o, dragTransition: a, dragSnapToOrigin: s, onDragTransitionEnd: r } = this.getProps(), l = this.constraints || {}, c = I((u) => {
+      if (!lt(u, n, this.currentDirection))
+        return;
+      let f = l && l[u] || {};
+      s && (f = { min: 0, max: 0 });
+      const h = o ? 200 : 1e6, d = o ? 40 : 1e7, m = {
+        type: "inertia",
+        velocity: i ? e[u] : 0,
+        bounceStiffness: h,
+        bounceDamping: d,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...a,
+        ...f
+      };
+      return this.startAxisValueAnimation(u, m);
+    });
+    return Promise.all(c).then(r);
+  }
+  startAxisValueAnimation(e, n) {
+    const i = this.getAxisMotionValue(e);
+    return oe(this.visualElement, e), i.start(Vi(e, i, 0, n, this.visualElement, !1));
+  }
+  stopAnimation() {
+    I((e) => this.getAxisMotionValue(e).stop());
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(e) {
+    const n = `_drag${e.toUpperCase()}`, i = this.visualElement.getProps(), o = i[n];
+    return o || this.visualElement.getValue(e, (i.initial ? i.initial[e] : void 0) || 0);
+  }
+  snapToCursor(e) {
+    I((n) => {
+      const { drag: i } = this.getProps();
+      if (!lt(n, i, this.currentDirection))
+        return;
+      const { projection: o } = this.visualElement, a = this.getAxisMotionValue(n);
+      if (o && o.layout) {
+        const { min: s, max: r } = o.layout.layoutBox[n], l = a.get() || 0;
+        a.set(e[n] - D(s, r, 0.5) + l);
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: e, dragConstraints: n } = this.getProps(), { projection: i } = this.visualElement;
+    if (!X(n) || !i || !this.constraints)
+      return;
+    this.stopAnimation();
+    const o = { x: 0, y: 0 };
+    I((s) => {
+      const r = this.getAxisMotionValue(s);
+      if (r && this.constraints !== !1) {
+        const l = r.get();
+        o[s] = Lo({ min: l, max: l }, this.constraints[s]);
+      }
+    });
+    const { transformTemplate: a } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = a ? a({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.constraints = !1, this.resolveConstraints(), I((s) => {
+      if (!lt(s, e, null))
+        return;
+      const r = this.getAxisMotionValue(s), { min: l, max: c } = this.constraints[s];
+      r.set(D(l, c, o[s]));
+    }), this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    bo.set(this.visualElement, this);
+    const e = this.visualElement.current, n = Q(e, "pointerdown", (c) => {
+      const { drag: u, dragListener: f = !0 } = this.getProps(), h = c.target, d = h !== e && Fi(h);
+      u && f && !d && this.start(c);
+    });
+    let i;
+    const o = () => {
+      const { dragConstraints: c } = this.getProps();
+      X(c) && c.current && (this.constraints = this.resolveRefConstraints(), i || (i = ko(e, c.current, () => this.scalePositionWithinConstraints())));
+    }, { projection: a } = this.visualElement, s = a.addEventListener("measure", o);
+    a && !a.layout && (a.root && a.root.updateScroll(), a.updateLayout()), A.read(o);
+    const r = et(window, "resize", () => this.scalePositionWithinConstraints()), l = a.addEventListener("didUpdate", (({ delta: c, hasLayoutChanged: u }) => {
+      this.isDragging && u && (I((f) => {
+        const h = this.getAxisMotionValue(f);
+        h && (this.originPoint[f] += c[f].translate, h.set(h.get() + c[f].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      r(), n(), s(), l && l(), i && i();
+    };
+  }
+  getProps() {
+    const e = this.visualElement.getProps(), { drag: n = !1, dragDirectionLock: i = !1, dragPropagation: o = !1, dragConstraints: a = !1, dragElastic: s = Ft, dragMomentum: r = !0 } = e;
+    return {
+      ...e,
+      drag: n,
+      dragDirectionLock: i,
+      dragPropagation: o,
+      dragConstraints: a,
+      dragElastic: s,
+      dragMomentum: r
+    };
+  }
+}
+function Ye(t) {
+  let e = !0;
+  return () => {
+    if (e) {
+      e = !1;
+      return;
+    }
+    t();
+  };
+}
+function ko(t, e, n) {
+  const i = ce(t, Ye(n)), o = ce(e, Ye(n));
+  return () => {
+    i(), o();
+  };
+}
+function lt(t, e, n) {
+  return (e === !0 || e === t) && (n === null || n === t);
+}
+function jo(t, e = 10) {
+  let n = null;
+  return Math.abs(t.y) > e ? n = "y" : Math.abs(t.x) > e && (n = "x"), n;
+}
+class Io extends U {
+  constructor(e) {
+    super(e), this.removeGroupControls = K, this.removeListeners = K, this.controls = new Mo(e);
+  }
+  mount() {
+    const { dragControls: e } = this.node.getProps();
+    e && (this.removeGroupControls = e.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || K;
+  }
+  update() {
+    const { dragControls: e } = this.node.getProps(), { dragControls: n } = this.node.prevProps || {};
+    e !== n && (this.removeGroupControls(), e && (this.removeGroupControls = e.subscribe(this.controls)));
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
+  }
+}
+const bt = (t) => (e, n) => {
+  t && A.update(() => t(e, n), !1, !0);
+};
+class Bo extends U {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = K;
+  }
+  onPointerDown(e) {
+    this.session = new Hn(e, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: Wn(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: e, onPanStart: n, onPan: i, onPanEnd: o } = this.node.getProps();
+    return {
+      onSessionStart: bt(e),
+      onStart: bt(n),
+      onMove: bt(i),
+      onEnd: (a, s) => {
+        delete this.session, o && A.postRender(() => o(a, s));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = Q(this.node.current, "pointerdown", (e) => this.onPointerDown(e));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+}
+let Mt = !1;
+class Oo extends Jn {
+  /**
+   * This only mounts projection nodes for components that
+   * need measuring, we might want to do it for all components
+   * in order to incorporate transforms
+   */
+  componentDidMount() {
+    const { visualElement: e, layoutGroup: n, switchLayoutGroup: i, layoutId: o } = this.props, { projection: a } = e;
+    a && (n.group && n.group.add(a), i && i.register && o && i.register(a), Mt && a.root.didUpdate(), a.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), a.setOptions({
+      ...a.options,
+      layoutDependency: this.props.layoutDependency,
+      onExitComplete: () => this.safeToRemove()
+    })), mt.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(e) {
+    const { layoutDependency: n, visualElement: i, drag: o, isPresent: a } = this.props, { projection: s } = i;
+    return s && (s.isPresent = a, e.layoutDependency !== n && s.setOptions({
+      ...s.options,
+      layoutDependency: n
+    }), Mt = !0, o || e.layoutDependency !== n || n === void 0 || e.isPresent !== a ? s.willUpdate() : this.safeToRemove(), e.isPresent !== a && (a ? s.promote() : s.relegate() || A.postRender(() => {
+      const r = s.getStack();
+      (!r || !r.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { projection: e } = this.props.visualElement;
+    e && (e.root.didUpdate(), an.postRender(() => {
+      !e.currentAnimation && e.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: e, layoutGroup: n, switchLayoutGroup: i } = this.props, { projection: o } = e;
+    Mt = !0, o && (o.scheduleCheckAfterUnmount(), n && n.group && n.group.remove(o), i && i.deregister && i.deregister(o));
+  }
+  safeToRemove() {
+    const { safeToRemove: e } = this.props;
+    e && e();
+  }
+  render() {
+    return null;
+  }
+}
+function zn(t) {
+  const [e, n] = bn(), i = C(Yt);
+  return N(Oo, { ...t, layoutGroup: i, switchLayoutGroup: C(Fn), isPresent: e, safeToRemove: n });
+}
+const Fo = {
+  pan: {
+    Feature: Bo
+  },
+  drag: {
+    Feature: Io,
+    ProjectionNode: Rn,
+    MeasureLayout: zn
+  }
+};
+function _e(t, e, n) {
+  const { props: i } = t;
+  t.animationState && i.whileHover && t.animationState.setActive("whileHover", n === "Start");
+  const o = "onHover" + n, a = i[o];
+  a && A.postRender(() => a(e, it(e)));
+}
+class Uo extends U {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = ji(e, (n, i) => (_e(this.node, i, "Start"), (o) => _e(this.node, o, "End"))));
+  }
+  unmount() {
+  }
+}
+class Wo extends U {
+  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 = hn(et(this.node.current, "focus", () => this.onFocus()), et(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+function Ke(t, e, n) {
+  const { props: i } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled)
+    return;
+  t.animationState && i.whileTap && t.animationState.setActive("whileTap", n === "Start");
+  const o = "onTap" + (n === "End" ? "" : n), a = i[o];
+  a && A.postRender(() => a(e, it(e)));
+}
+class Ho extends U {
+  mount() {
+    const { current: e } = this.node;
+    if (!e)
+      return;
+    const { globalTapTarget: n, propagate: i } = this.node.props;
+    this.unmount = Wi(e, (o, a) => (Ke(this.node, a, "Start"), (s, { success: r }) => Ke(this.node, s, r ? "End" : "Cancel")), {
+      useGlobalTarget: n,
+      stopPropagation: i?.tap === !1
+    });
+  }
+  unmount() {
+  }
+}
+const Ut = /* @__PURE__ */ new WeakMap(), kt = /* @__PURE__ */ new WeakMap(), No = (t) => {
+  const e = Ut.get(t.target);
+  e && e(t);
+}, zo = (t) => {
+  t.forEach(No);
+};
+function Go({ root: t, ...e }) {
+  const n = t || document;
+  kt.has(n) || kt.set(n, {});
+  const i = kt.get(n), o = JSON.stringify(e);
+  return i[o] || (i[o] = new IntersectionObserver(zo, { root: t, ...e })), i[o];
+}
+function $o(t, e, n) {
+  const i = Go(e);
+  return Ut.set(t, n), i.observe(t), () => {
+    Ut.delete(t), i.unobserve(t);
+  };
+}
+const Xo = {
+  some: 0,
+  all: 1
+};
+class Yo extends U {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: e = {} } = this.node.getProps(), { root: n, margin: i, amount: o = "some", once: a } = e, s = {
+      root: n ? n.current : void 0,
+      rootMargin: i,
+      threshold: typeof o == "number" ? o : Xo[o]
+    }, r = (l) => {
+      const { isIntersecting: c } = l;
+      if (this.isInView === c || (this.isInView = c, a && !c && this.hasEnteredView))
+        return;
+      c && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", c);
+      const { onViewportEnter: u, onViewportLeave: f } = this.node.getProps(), h = c ? u : f;
+      h && h(l);
+    };
+    return $o(this.node.current, s, r);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: e, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(_o(e, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function _o({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (n) => t[n] !== e[n];
+}
+const Ko = {
+  inView: {
+    Feature: Yo
+  },
+  tap: {
+    Feature: Ho
+  },
+  focus: {
+    Feature: Wo
+  },
+  hover: {
+    Feature: Uo
+  }
+}, qo = {
+  layout: {
+    ProjectionNode: Rn,
+    MeasureLayout: zn
+  }
+}, Zo = {
+  ...xo,
+  ...Ko,
+  ...Fo,
+  ...qo
+}, sr = /* @__PURE__ */ po(Zo, go);
+export {
+  ir as A,
+  Yt as L,
+  Ys as l,
+  sr as m,
+  dn as u
+};
+//# sourceMappingURL=proxy-BZcQiBrp.js.map