@zydon/common 1.1.70 → 1.1.72

package/dist/features-4a4adf3e.js

@@ -0,0 +1,2992 @@
+import { p as rt, f as C, n as B, r as mn, c as gn, i as tt, d as Ts, a as yn, v as Vs, w as ie, b as yt, e as $, g as R, t as Pt, h as et, j as Ss, k as bs, l as k, m as nt, o as vn, q as xt, s as vt, u as As, x as Ds, y as Cs, z as at, A as Ms, B as Pn, C as $t, D as xn, E as Tn, F as w, G as zt, H as dt, P as ws, I as Ls, L as Rs, S as Bs, J as Vn, K as Sn, M as bn, N as Et, O as jt, Q as ye, R as Ht, T as Fs, U as An, V as Dn, W as Es, X as js, Y as Cn, Z as Mn, _ as ks, $ as Is, a0 as Os, a1 as Us, a2 as Ns, a3 as Gs, a4 as Ks, a5 as $s, a6 as zs, a7 as Hs } from "./index-be3b99f0.js";
+import wn, { useContext as _t, useId as _s, useEffect as Ws } from "react";
+import "@mui/material";
+import "@emotion/react";
+import "react-dom";
+import "@mui/x-date-pickers-pro";
+import "@mui/lab";
+import "@mui/x-data-grid-premium";
+import "@emotion/styled";
+import "react-hook-form";
+function N(e, t, n, s = { passive: !0 }) {
+  return e.addEventListener(t, n, s), () => e.removeEventListener(t, n);
+}
+const Ln = (e) => e.pointerType === "mouse" ? typeof e.button != "number" || e.button <= 0 : e.isPrimary !== !1;
+function Rt(e, t = "page") {
+  return {
+    point: {
+      x: e[t + "X"],
+      y: e[t + "Y"]
+    }
+  };
+}
+const Ys = (e) => (t) => Ln(t) && e(t, Rt(t));
+function G(e, t, n, s) {
+  return N(e, t, Ys(n), s);
+}
+function Rn(e) {
+  let t = null;
+  return () => {
+    const n = () => {
+      t = null;
+    };
+    return t === null ? (t = e, n) : !1;
+  };
+}
+const ve = Rn("dragHorizontal"), Pe = Rn("dragVertical");
+function Bn(e) {
+  let t = !1;
+  if (e === "y")
+    t = Pe();
+  else if (e === "x")
+    t = ve();
+  else {
+    const n = ve(), s = Pe();
+    n && s ? t = () => {
+      n(), s();
+    } : (n && n(), s && s());
+  }
+  return t;
+}
+function Fn() {
+  const e = Bn(!0);
+  return e ? (e(), !1) : !0;
+}
+class q {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
+  }
+  update() {
+  }
+}
+function xe(e, t) {
+  const n = "pointer" + (t ? "enter" : "leave"), s = "onHover" + (t ? "Start" : "End"), o = (c, i) => {
+    if (c.type === "touch" || Fn())
+      return;
+    const r = e.getProps();
+    e.animationState && r.whileHover && e.animationState.setActive("whileHover", t), r[s] && C.update(() => r[s](c, i));
+  };
+  return G(e.current, n, o, {
+    passive: !e.getProps()[s]
+  });
+}
+class qs extends q {
+  mount() {
+    this.unmount = rt(xe(this.node, !0), xe(this.node, !1));
+  }
+  unmount() {
+  }
+}
+class Xs extends q {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.node.current.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    !t || !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 = rt(N(this.node.current, "focus", () => this.onFocus()), N(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+const En = (e, t) => t ? e === t ? !0 : En(e, t.parentElement) : !1;
+function kt(e, t) {
+  if (!t)
+    return;
+  const n = new PointerEvent("pointer" + e);
+  t(n, Rt(n));
+}
+class Zs extends q {
+  constructor() {
+    super(...arguments), this.removeStartListeners = B, this.removeEndListeners = B, this.removeAccessibleListeners = B, this.startPointerPress = (t, n) => {
+      if (this.removeEndListeners(), this.isPressing)
+        return;
+      const s = this.node.getProps(), c = G(window, "pointerup", (r, a) => {
+        if (!this.checkPressEnd())
+          return;
+        const { onTap: l, onTapCancel: u } = this.node.getProps();
+        C.update(() => {
+          En(this.node.current, r.target) ? l && l(r, a) : u && u(r, a);
+        });
+      }, { passive: !(s.onTap || s.onPointerUp) }), i = G(window, "pointercancel", (r, a) => this.cancelPress(r, a), { passive: !(s.onTapCancel || s.onPointerCancel) });
+      this.removeEndListeners = rt(c, i), this.startPress(t, n);
+    }, this.startAccessiblePress = () => {
+      const t = (c) => {
+        if (c.key !== "Enter" || this.isPressing)
+          return;
+        const i = (r) => {
+          r.key !== "Enter" || !this.checkPressEnd() || kt("up", (a, l) => {
+            const { onTap: u } = this.node.getProps();
+            u && C.update(() => u(a, l));
+          });
+        };
+        this.removeEndListeners(), this.removeEndListeners = N(this.node.current, "keyup", i), kt("down", (r, a) => {
+          this.startPress(r, a);
+        });
+      }, n = N(this.node.current, "keydown", t), s = () => {
+        this.isPressing && kt("cancel", (c, i) => this.cancelPress(c, i));
+      }, o = N(this.node.current, "blur", s);
+      this.removeAccessibleListeners = rt(n, o);
+    };
+  }
+  startPress(t, n) {
+    this.isPressing = !0;
+    const { onTapStart: s, whileTap: o } = this.node.getProps();
+    o && this.node.animationState && this.node.animationState.setActive("whileTap", !0), s && C.update(() => s(t, n));
+  }
+  checkPressEnd() {
+    return this.removeEndListeners(), this.isPressing = !1, this.node.getProps().whileTap && this.node.animationState && this.node.animationState.setActive("whileTap", !1), !Fn();
+  }
+  cancelPress(t, n) {
+    if (!this.checkPressEnd())
+      return;
+    const { onTapCancel: s } = this.node.getProps();
+    s && C.update(() => s(t, n));
+  }
+  mount() {
+    const t = this.node.getProps(), n = G(this.node.current, "pointerdown", this.startPointerPress, { passive: !(t.onTapStart || t.onPointerStart) }), s = N(this.node.current, "focus", this.startAccessiblePress);
+    this.removeStartListeners = rt(n, s);
+  }
+  unmount() {
+    this.removeStartListeners(), this.removeEndListeners(), this.removeAccessibleListeners();
+  }
+}
+const Wt = /* @__PURE__ */ new WeakMap(), It = /* @__PURE__ */ new WeakMap(), Js = (e) => {
+  const t = Wt.get(e.target);
+  t && t(e);
+}, Qs = (e) => {
+  e.forEach(Js);
+};
+function ti({ root: e, ...t }) {
+  const n = e || document;
+  It.has(n) || It.set(n, {});
+  const s = It.get(n), o = JSON.stringify(t);
+  return s[o] || (s[o] = new IntersectionObserver(Qs, { root: e, ...t })), s[o];
+}
+function ei(e, t, n) {
+  const s = ti(t);
+  return Wt.set(e, n), s.observe(e), () => {
+    Wt.delete(e), s.unobserve(e);
+  };
+}
+const ni = {
+  some: 0,
+  all: 1
+};
+class si extends q {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: t = {} } = this.node.getProps(), { root: n, margin: s, amount: o = "some", once: c } = t, i = {
+      root: n ? n.current : void 0,
+      rootMargin: s,
+      threshold: typeof o == "number" ? o : ni[o]
+    }, r = (a) => {
+      const { isIntersecting: l } = a;
+      if (this.isInView === l || (this.isInView = l, c && !l && this.hasEnteredView))
+        return;
+      l && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", l);
+      const { onViewportEnter: u, onViewportLeave: h } = this.node.getProps(), f = l ? u : h;
+      f && f(a);
+    };
+    return ei(this.node.current, i, r);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: t, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(ii(t, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function ii({ viewport: e = {} }, { viewport: t = {} } = {}) {
+  return (n) => e[n] !== t[n];
+}
+const oi = {
+  inView: {
+    Feature: si
+  },
+  tap: {
+    Feature: Zs
+  },
+  focus: {
+    Feature: Xs
+  },
+  hover: {
+    Feature: qs
+  }
+};
+function jn(e, t) {
+  if (!Array.isArray(t))
+    return !1;
+  const n = t.length;
+  if (n !== e.length)
+    return !1;
+  for (let s = 0; s < n; s++)
+    if (t[s] !== e[s])
+      return !1;
+  return !0;
+}
+function ri(e) {
+  const t = {};
+  return e.values.forEach((n, s) => t[s] = n.get()), t;
+}
+function ai(e) {
+  const t = {};
+  return e.values.forEach((n, s) => t[s] = n.getVelocity()), t;
+}
+function Bt(e, t, n) {
+  const s = e.getProps();
+  return mn(s, t, n !== void 0 ? n : s.custom, ri(e), ai(e));
+}
+const li = "framerAppearId", ci = "data-" + gn(li), Y = (e) => e * 1e3, K = (e) => e / 1e3, ui = {
+  current: !1
+}, kn = (e) => Array.isArray(e) && typeof e[0] == "number";
+function In(e) {
+  return !!(!e || typeof e == "string" && On[e] || kn(e) || Array.isArray(e) && e.every(In));
+}
+const pt = ([e, t, n, s]) => `cubic-bezier(${e}, ${t}, ${n}, ${s})`, On = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: pt([0, 0.65, 0.55, 1]),
+  circOut: pt([0.55, 0, 1, 0.45]),
+  backIn: pt([0.31, 0.01, 0.66, -0.59]),
+  backOut: pt([0.33, 1.53, 0.69, 0.99])
+};
+function Un(e) {
+  if (e)
+    return kn(e) ? pt(e) : Array.isArray(e) ? e.map(Un) : On[e];
+}
+function hi(e, t, n, { delay: s = 0, duration: o, repeat: c = 0, repeatType: i = "loop", ease: r, times: a } = {}) {
+  const l = { [t]: n };
+  a && (l.offset = a);
+  const u = Un(r);
+  return Array.isArray(u) && (l.easing = u), e.animate(l, {
+    delay: s,
+    duration: o,
+    easing: Array.isArray(u) ? "linear" : u,
+    fill: "both",
+    iterations: c + 1,
+    direction: i === "reverse" ? "alternate" : "normal"
+  });
+}
+function fi(e, { repeat: t, repeatType: n = "loop" }) {
+  const s = t && n !== "loop" && t % 2 === 1 ? 0 : e.length - 1;
+  return e[s];
+}
+const Nn = (e, t, n) => (((1 - 3 * n + 3 * t) * e + (3 * n - 6 * t)) * e + 3 * t) * e, di = 1e-7, pi = 12;
+function mi(e, t, n, s, o) {
+  let c, i, r = 0;
+  do
+    i = t + (n - t) / 2, c = Nn(i, s, o) - e, c > 0 ? n = i : t = i;
+  while (Math.abs(c) > di && ++r < pi);
+  return i;
+}
+function Tt(e, t, n, s) {
+  if (e === t && n === s)
+    return B;
+  const o = (c) => mi(c, 0, 1, e, n);
+  return (c) => c === 0 || c === 1 ? c : Nn(o(c), t, s);
+}
+const gi = Tt(0.42, 0, 1, 1), yi = Tt(0, 0, 0.58, 1), Gn = Tt(0.42, 0, 0.58, 1), vi = (e) => Array.isArray(e) && typeof e[0] != "number", Kn = (e) => (t) => t <= 0.5 ? e(2 * t) / 2 : (2 - e(2 * (1 - t))) / 2, $n = (e) => (t) => 1 - e(1 - t), zn = (e) => 1 - Math.sin(Math.acos(e)), oe = $n(zn), Pi = Kn(oe), Hn = Tt(0.33, 1.53, 0.69, 0.99), re = $n(Hn), xi = Kn(re), Ti = (e) => (e *= 2) < 1 ? 0.5 * re(e) : 0.5 * (2 - Math.pow(2, -10 * (e - 1))), Te = {
+  linear: B,
+  easeIn: gi,
+  easeInOut: Gn,
+  easeOut: yi,
+  circIn: zn,
+  circInOut: Pi,
+  circOut: oe,
+  backIn: re,
+  backInOut: xi,
+  backOut: Hn,
+  anticipate: Ti
+}, Ve = (e) => {
+  if (Array.isArray(e)) {
+    tt(e.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [t, n, s, o] = e;
+    return Tt(t, n, s, o);
+  } else if (typeof e == "string")
+    return tt(Te[e] !== void 0, `Invalid easing type '${e}'`), Te[e];
+  return e;
+};
+function Vi(e, t) {
+  return e.map((n) => n * t);
+}
+function Si(e, t) {
+  return e.map(() => t || Gn).splice(0, e.length - 1);
+}
+function Ct({ duration: e = 300, keyframes: t, times: n, ease: s = "easeInOut" }) {
+  const o = vi(s) ? s.map(Ve) : Ve(s), c = {
+    done: !1,
+    value: t[0]
+  }, i = Vi(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    n && n.length === t.length ? n : Ts(t),
+    e
+  ), r = yn(i, t, {
+    ease: Array.isArray(o) ? o : Si(t, o)
+  });
+  return {
+    calculatedDuration: e,
+    next: (a) => (c.value = r(a), c.done = a >= e, c)
+  };
+}
+const bi = 5;
+function _n(e, t, n) {
+  const s = Math.max(t - bi, 0);
+  return Vs(n - e(s), t - s);
+}
+const Ot = 1e-3, Ai = 0.01, Se = 10, Di = 0.05, Ci = 1;
+function Mi({ duration: e = 800, bounce: t = 0.25, velocity: n = 0, mass: s = 1 }) {
+  let o, c;
+  ie(e <= Y(Se), "Spring duration must be 10 seconds or less");
+  let i = 1 - t;
+  i = yt(Di, Ci, i), e = yt(Ai, Se, K(e)), i < 1 ? (o = (l) => {
+    const u = l * i, h = u * e, f = u - n, d = Yt(l, i), p = Math.exp(-h);
+    return Ot - f / d * p;
+  }, c = (l) => {
+    const h = l * i * e, f = h * n + n, d = Math.pow(i, 2) * Math.pow(l, 2) * e, p = Math.exp(-h), m = Yt(Math.pow(l, 2), i);
+    return (-o(l) + Ot > 0 ? -1 : 1) * ((f - d) * p) / m;
+  }) : (o = (l) => {
+    const u = Math.exp(-l * e), h = (l - n) * e + 1;
+    return -Ot + u * h;
+  }, c = (l) => {
+    const u = Math.exp(-l * e), h = (n - l) * (e * e);
+    return u * h;
+  });
+  const r = 5 / e, a = Li(o, c, r);
+  if (e = Y(e), isNaN(a))
+    return {
+      stiffness: 100,
+      damping: 10,
+      duration: e
+    };
+  {
+    const l = Math.pow(a, 2) * s;
+    return {
+      stiffness: l,
+      damping: i * 2 * Math.sqrt(s * l),
+      duration: e
+    };
+  }
+}
+const wi = 12;
+function Li(e, t, n) {
+  let s = n;
+  for (let o = 1; o < wi; o++)
+    s = s - e(s) / t(s);
+  return s;
+}
+function Yt(e, t) {
+  return e * Math.sqrt(1 - t * t);
+}
+const Ri = ["duration", "bounce"], Bi = ["stiffness", "damping", "mass"];
+function be(e, t) {
+  return t.some((n) => e[n] !== void 0);
+}
+function Fi(e) {
+  let t = {
+    velocity: 0,
+    stiffness: 100,
+    damping: 10,
+    mass: 1,
+    isResolvedFromDuration: !1,
+    ...e
+  };
+  if (!be(e, Bi) && be(e, Ri)) {
+    const n = Mi(e);
+    t = {
+      ...t,
+      ...n,
+      velocity: 0,
+      mass: 1
+    }, t.isResolvedFromDuration = !0;
+  }
+  return t;
+}
+function Wn({ keyframes: e, restDelta: t, restSpeed: n, ...s }) {
+  const o = e[0], c = e[e.length - 1], i = { done: !1, value: o }, { stiffness: r, damping: a, mass: l, velocity: u, duration: h, isResolvedFromDuration: f } = Fi(s), d = u ? -K(u) : 0, p = a / (2 * Math.sqrt(r * l)), m = c - o, v = K(Math.sqrt(r / l)), V = Math.abs(m) < 5;
+  n || (n = V ? 0.01 : 2), t || (t = V ? 5e-3 : 0.5);
+  let y;
+  if (p < 1) {
+    const g = Yt(v, p);
+    y = (P) => {
+      const x = Math.exp(-p * v * P);
+      return c - x * ((d + p * v * m) / g * Math.sin(g * P) + m * Math.cos(g * P));
+    };
+  } else if (p === 1)
+    y = (g) => c - Math.exp(-v * g) * (m + (d + v * m) * g);
+  else {
+    const g = v * Math.sqrt(p * p - 1);
+    y = (P) => {
+      const x = Math.exp(-p * v * P), F = Math.min(g * P, 300);
+      return c - x * ((d + p * v * m) * Math.sinh(F) + g * m * Math.cosh(F)) / g;
+    };
+  }
+  return {
+    calculatedDuration: f && h || null,
+    next: (g) => {
+      const P = y(g);
+      if (f)
+        i.done = g >= h;
+      else {
+        let x = d;
+        g !== 0 && (p < 1 ? x = _n(y, g, P) : x = 0);
+        const F = Math.abs(x) <= n, S = Math.abs(c - P) <= t;
+        i.done = F && S;
+      }
+      return i.value = i.done ? c : P, i;
+    }
+  };
+}
+function Ae({ keyframes: e, velocity: t = 0, power: n = 0.8, timeConstant: s = 325, bounceDamping: o = 10, bounceStiffness: c = 500, modifyTarget: i, min: r, max: a, restDelta: l = 0.5, restSpeed: u }) {
+  const h = e[0], f = {
+    done: !1,
+    value: h
+  }, d = (T) => r !== void 0 && T < r || a !== void 0 && T > a, p = (T) => r === void 0 ? a : a === void 0 || Math.abs(r - T) < Math.abs(a - T) ? r : a;
+  let m = n * t;
+  const v = h + m, V = i === void 0 ? v : i(v);
+  V !== v && (m = V - h);
+  const y = (T) => -m * Math.exp(-T / s), g = (T) => V + y(T), P = (T) => {
+    const A = y(T), O = g(T);
+    f.done = Math.abs(A) <= l, f.value = f.done ? V : O;
+  };
+  let x, F;
+  const S = (T) => {
+    d(f.value) && (x = T, F = Wn({
+      keyframes: [f.value, p(f.value)],
+      velocity: _n(g, T, f.value),
+      damping: o,
+      stiffness: c,
+      restDelta: l,
+      restSpeed: u
+    }));
+  };
+  return S(0), {
+    calculatedDuration: null,
+    next: (T) => {
+      let A = !1;
+      return !F && x === void 0 && (A = !0, P(T), S(T)), x !== void 0 && T > x ? F.next(T - x) : (!A && P(T), f);
+    }
+  };
+}
+const Ei = (e) => {
+  const t = ({ timestamp: n }) => e(n);
+  return {
+    start: () => C.update(t, !0),
+    stop: () => $(t),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => R.isProcessing ? R.timestamp : performance.now()
+  };
+}, De = 2e4;
+function Ce(e) {
+  let t = 0;
+  const n = 50;
+  let s = e.next(t);
+  for (; !s.done && t < De; )
+    t += n, s = e.next(t);
+  return t >= De ? 1 / 0 : t;
+}
+const ji = {
+  decay: Ae,
+  inertia: Ae,
+  tween: Ct,
+  keyframes: Ct,
+  spring: Wn
+};
+function Mt({ autoplay: e = !0, delay: t = 0, driver: n = Ei, keyframes: s, type: o = "keyframes", repeat: c = 0, repeatDelay: i = 0, repeatType: r = "loop", onPlay: a, onStop: l, onComplete: u, onUpdate: h, ...f }) {
+  let d = 1, p = !1, m, v;
+  const V = () => {
+    v = new Promise((b) => {
+      m = b;
+    });
+  };
+  V();
+  let y;
+  const g = ji[o] || Ct;
+  let P;
+  g !== Ct && typeof s[0] != "number" && (P = yn([0, 100], s, {
+    clamp: !1
+  }), s = [0, 100]);
+  const x = g({ ...f, keyframes: s });
+  let F;
+  r === "mirror" && (F = g({
+    ...f,
+    keyframes: [...s].reverse(),
+    velocity: -(f.velocity || 0)
+  }));
+  let S = "idle", T = null, A = null, O = null;
+  x.calculatedDuration === null && c && (x.calculatedDuration = Ce(x));
+  const { calculatedDuration: U } = x;
+  let z = 1 / 0, H = 1 / 0;
+  U !== null && (z = U + i, H = z * (c + 1) - i);
+  let L = 0;
+  const M = (b) => {
+    if (A === null)
+      return;
+    d > 0 && (A = Math.min(A, b)), d < 0 && (A = Math.min(b - H / d, A)), T !== null ? L = T : L = Math.round(b - A) * d;
+    const ct = L - t * (d >= 0 ? 1 : -1), he = d >= 0 ? ct < 0 : ct > H;
+    L = Math.max(ct, 0), S === "finished" && T === null && (L = H);
+    let fe = L, de = x;
+    if (c) {
+      const Ft = L / z;
+      let Vt = Math.floor(Ft), X = Ft % 1;
+      !X && Ft >= 1 && (X = 1), X === 1 && Vt--, Vt = Math.min(Vt, c + 1);
+      const me = !!(Vt % 2);
+      me && (r === "reverse" ? (X = 1 - X, i && (X -= i / z)) : r === "mirror" && (de = F));
+      let ge = yt(0, 1, X);
+      L > H && (ge = r === "reverse" && me ? 1 : 0), fe = ge * z;
+    }
+    const ut = he ? { done: !1, value: s[0] } : de.next(fe);
+    P && (ut.value = P(ut.value));
+    let { done: pe } = ut;
+    !he && U !== null && (pe = d >= 0 ? L >= H : L <= 0);
+    const xs = T === null && (S === "finished" || S === "running" && pe);
+    return h && h(ut.value), xs && Ps(), ut;
+  }, _ = () => {
+    y && y.stop(), y = void 0;
+  }, st = () => {
+    S = "idle", _(), m(), V(), A = O = null;
+  }, Ps = () => {
+    S = "finished", u && u(), _(), m();
+  }, ce = () => {
+    if (p)
+      return;
+    y || (y = n(M));
+    const b = y.now();
+    a && a(), T !== null ? A = b - T : (!A || S === "finished") && (A = b), S === "finished" && V(), O = A, T = null, S = "running", y.start();
+  };
+  e && ce();
+  const ue = {
+    then(b, ct) {
+      return v.then(b, ct);
+    },
+    get time() {
+      return K(L);
+    },
+    set time(b) {
+      b = Y(b), L = b, T !== null || !y || d === 0 ? T = b : A = y.now() - b / d;
+    },
+    get duration() {
+      const b = x.calculatedDuration === null ? Ce(x) : x.calculatedDuration;
+      return K(b);
+    },
+    get speed() {
+      return d;
+    },
+    set speed(b) {
+      b === d || !y || (d = b, ue.time = K(L));
+    },
+    get state() {
+      return S;
+    },
+    play: ce,
+    pause: () => {
+      S = "paused", T = L;
+    },
+    stop: () => {
+      p = !0, S !== "idle" && (S = "idle", l && l(), st());
+    },
+    cancel: () => {
+      O !== null && M(O), st();
+    },
+    complete: () => {
+      S = "finished";
+    },
+    sample: (b) => (A = 0, M(b))
+  };
+  return ue;
+}
+function ki(e) {
+  let t;
+  return () => (t === void 0 && (t = e()), t);
+}
+const Ii = ki(() => Object.hasOwnProperty.call(Element.prototype, "animate")), Oi = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform",
+  "backgroundColor"
+]), St = 10, Ui = 2e4, Ni = (e, t) => t.type === "spring" || e === "backgroundColor" || !In(t.ease);
+function Gi(e, t, { onUpdate: n, onComplete: s, ...o }) {
+  if (!(Ii() && Oi.has(t) && !o.repeatDelay && o.repeatType !== "mirror" && o.damping !== 0 && o.type !== "inertia"))
+    return !1;
+  let i = !1, r, a;
+  const l = () => {
+    a = new Promise((y) => {
+      r = y;
+    });
+  };
+  l();
+  let { keyframes: u, duration: h = 300, ease: f, times: d } = o;
+  if (Ni(t, o)) {
+    const y = Mt({
+      ...o,
+      repeat: 0,
+      delay: 0
+    });
+    let g = { done: !1, value: u[0] };
+    const P = [];
+    let x = 0;
+    for (; !g.done && x < Ui; )
+      g = y.sample(x), P.push(g.value), x += St;
+    d = void 0, u = P, h = x - St, f = "linear";
+  }
+  const p = hi(e.owner.current, t, u, {
+    ...o,
+    duration: h,
+    /**
+     * This function is currently not called if ease is provided
+     * as a function so the cast is safe.
+     *
+     * However it would be possible for a future refinement to port
+     * in easing pregeneration from Motion One for browsers that
+     * support the upcoming `linear()` easing function.
+     */
+    ease: f,
+    times: d
+  });
+  o.syncStart && (p.startTime = R.isProcessing ? R.timestamp : document.timeline ? document.timeline.currentTime : performance.now());
+  const m = () => p.cancel(), v = () => {
+    C.update(m), r(), l();
+  };
+  return p.onfinish = () => {
+    e.set(fi(u, o)), s && s(), v();
+  }, {
+    then(y, g) {
+      return a.then(y, g);
+    },
+    attachTimeline(y) {
+      return p.timeline = y, p.onfinish = null, B;
+    },
+    get time() {
+      return K(p.currentTime || 0);
+    },
+    set time(y) {
+      p.currentTime = Y(y);
+    },
+    get speed() {
+      return p.playbackRate;
+    },
+    set speed(y) {
+      p.playbackRate = y;
+    },
+    get duration() {
+      return K(h);
+    },
+    play: () => {
+      i || (p.play(), $(m));
+    },
+    pause: () => p.pause(),
+    stop: () => {
+      if (i = !0, p.playState === "idle")
+        return;
+      const { currentTime: y } = p;
+      if (y) {
+        const g = Mt({
+          ...o,
+          autoplay: !1
+        });
+        e.setWithVelocity(g.sample(y - St).value, g.sample(y).value, St);
+      }
+      v();
+    },
+    complete: () => p.finish(),
+    cancel: v
+  };
+}
+function Ki({ keyframes: e, delay: t, onUpdate: n, onComplete: s }) {
+  const o = () => (n && n(e[e.length - 1]), s && s(), {
+    time: 0,
+    speed: 1,
+    duration: 0,
+    play: B,
+    pause: B,
+    stop: B,
+    then: (c) => (c(), Promise.resolve()),
+    cancel: B,
+    complete: B
+  });
+  return t ? Mt({
+    keyframes: [0, 1],
+    duration: 0,
+    delay: t,
+    onComplete: o
+  }) : o();
+}
+const $i = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, zi = (e) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: e === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), Hi = {
+  type: "keyframes",
+  duration: 0.8
+}, _i = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, Wi = (e, { keyframes: t }) => t.length > 2 ? Hi : Pt.has(e) ? e.startsWith("scale") ? zi(t[1]) : $i : _i, qt = (e, t) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(et.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url(")), Yi = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function qi(e) {
+  const [t, n] = e.slice(0, -1).split("(");
+  if (t === "drop-shadow")
+    return e;
+  const [s] = n.match(Ss) || [];
+  if (!s)
+    return e;
+  const o = n.replace(s, "");
+  let c = Yi.has(t) ? 1 : 0;
+  return s !== n && (c *= 100), t + "(" + c + o + ")";
+}
+const Xi = /([a-z-]*)\(.*?\)/g, Xt = {
+  ...et,
+  getAnimatableNone: (e) => {
+    const t = e.match(Xi);
+    return t ? t.map(qi).join(" ") : e;
+  }
+}, Zi = {
+  ...bs,
+  // Color props
+  color: k,
+  backgroundColor: k,
+  outlineColor: k,
+  fill: k,
+  stroke: k,
+  // Border props
+  borderColor: k,
+  borderTopColor: k,
+  borderRightColor: k,
+  borderBottomColor: k,
+  borderLeftColor: k,
+  filter: Xt,
+  WebkitFilter: Xt
+}, ae = (e) => Zi[e];
+function Yn(e, t) {
+  let n = ae(e);
+  return n !== Xt && (n = et), n.getAnimatableNone ? n.getAnimatableNone(t) : void 0;
+}
+const qn = (e) => /^0[^.\s]+$/.test(e);
+function Ji(e) {
+  if (typeof e == "number")
+    return e === 0;
+  if (e !== null)
+    return e === "none" || e === "0" || qn(e);
+}
+function Qi(e, t, n, s) {
+  const o = qt(t, n);
+  let c;
+  Array.isArray(n) ? c = [...n] : c = [null, n];
+  const i = s.from !== void 0 ? s.from : e.get();
+  let r;
+  const a = [];
+  for (let l = 0; l < c.length; l++)
+    c[l] === null && (c[l] = l === 0 ? i : c[l - 1]), Ji(c[l]) && a.push(l), typeof c[l] == "string" && c[l] !== "none" && c[l] !== "0" && (r = c[l]);
+  if (o && a.length && r)
+    for (let l = 0; l < a.length; l++) {
+      const u = a[l];
+      c[u] = Yn(t, r);
+    }
+  return c;
+}
+function to({ when: e, delay: t, delayChildren: n, staggerChildren: s, staggerDirection: o, repeat: c, repeatType: i, repeatDelay: r, from: a, elapsed: l, ...u }) {
+  return !!Object.keys(u).length;
+}
+function Xn(e, t) {
+  return e[t] || e.default || e;
+}
+const le = (e, t, n, s = {}) => (o) => {
+  const c = Xn(s, e) || {}, i = c.delay || s.delay || 0;
+  let { elapsed: r = 0 } = s;
+  r = r - Y(i);
+  const a = Qi(t, e, n, c), l = a[0], u = a[a.length - 1], h = qt(e, l), f = qt(e, u);
+  ie(h === f, `You are trying to animate ${e} from "${l}" to "${u}". ${l} is not an animatable value - to enable this animation set ${l} to a value animatable to ${u} via the \`style\` property.`);
+  let d = {
+    keyframes: a,
+    velocity: t.getVelocity(),
+    ease: "easeOut",
+    ...c,
+    delay: -r,
+    onUpdate: (p) => {
+      t.set(p), c.onUpdate && c.onUpdate(p);
+    },
+    onComplete: () => {
+      o(), c.onComplete && c.onComplete();
+    }
+  };
+  if (to(c) || (d = {
+    ...d,
+    ...Wi(e, d)
+  }), d.duration && (d.duration = Y(d.duration)), d.repeatDelay && (d.repeatDelay = Y(d.repeatDelay)), !h || !f || ui.current || c.type === !1)
+    return Ki(d);
+  if (t.owner && t.owner.current instanceof HTMLElement && !t.owner.getProps().onUpdate) {
+    const p = Gi(t, e, d);
+    if (p)
+      return p;
+  }
+  return Mt(d);
+};
+function wt(e) {
+  return !!(nt(e) && e.add);
+}
+const Zn = (e) => /^\-?\d*\.?\d+$/.test(e), Jn = (e) => (t) => t.test(e), eo = {
+  test: (e) => e === "auto",
+  parse: (e) => e
+}, Qn = [vn, xt, vt, As, Ds, Cs, eo], ht = (e) => Qn.find(Jn(e)), no = [...Qn, k, et], so = (e) => no.find(Jn(e));
+function io(e, t, n) {
+  e.hasValue(t) ? e.getValue(t).set(n) : e.addValue(t, at(n));
+}
+function oo(e, t) {
+  const n = Bt(e, t);
+  let { transitionEnd: s = {}, transition: o = {}, ...c } = n ? e.makeTargetAnimatable(n, !1) : {};
+  c = { ...c, ...s };
+  for (const i in c) {
+    const r = Ms(c[i]);
+    io(e, i, r);
+  }
+}
+function ro(e, t, n) {
+  var s, o;
+  const c = Object.keys(t).filter((r) => !e.hasValue(r)), i = c.length;
+  if (i)
+    for (let r = 0; r < i; r++) {
+      const a = c[r], l = t[a];
+      let u = null;
+      Array.isArray(l) && (u = l[0]), u === null && (u = (o = (s = n[a]) !== null && s !== void 0 ? s : e.readValue(a)) !== null && o !== void 0 ? o : t[a]), u != null && (typeof u == "string" && (Zn(u) || qn(u)) ? u = parseFloat(u) : !so(u) && et.test(l) && (u = Yn(a, l)), e.addValue(a, at(u, { owner: e })), n[a] === void 0 && (n[a] = u), u !== null && e.setBaseTarget(a, u));
+    }
+}
+function ao(e, t) {
+  return t ? (t[e] || t.default || t).from : void 0;
+}
+function lo(e, t, n) {
+  const s = {};
+  for (const o in e) {
+    const c = ao(o, t);
+    if (c !== void 0)
+      s[o] = c;
+    else {
+      const i = n.getValue(o);
+      i && (s[o] = i.get());
+    }
+  }
+  return s;
+}
+function co({ protectedKeys: e, needsAnimating: t }, n) {
+  const s = e.hasOwnProperty(n) && t[n] !== !0;
+  return t[n] = !1, s;
+}
+function ts(e, t, { delay: n = 0, transitionOverride: s, type: o } = {}) {
+  let { transition: c = e.getDefaultTransition(), transitionEnd: i, ...r } = e.makeTargetAnimatable(t);
+  const a = e.getValue("willChange");
+  s && (c = s);
+  const l = [], u = o && e.animationState && e.animationState.getState()[o];
+  for (const h in r) {
+    const f = e.getValue(h), d = r[h];
+    if (!f || d === void 0 || u && co(u, h))
+      continue;
+    const p = {
+      delay: n,
+      elapsed: 0,
+      ...c
+    };
+    if (window.HandoffAppearAnimations && !f.hasAnimated) {
+      const v = e.getProps()[ci];
+      v && (p.elapsed = window.HandoffAppearAnimations(v, h, f, C), p.syncStart = !0);
+    }
+    f.start(le(h, f, d, e.shouldReduceMotion && Pt.has(h) ? { type: !1 } : p));
+    const m = f.animation;
+    wt(a) && (a.add(h), m.then(() => a.remove(h))), l.push(m);
+  }
+  return i && Promise.all(l).then(() => {
+    i && oo(e, i);
+  }), l;
+}
+function Zt(e, t, n = {}) {
+  const s = Bt(e, t, n.custom);
+  let { transition: o = e.getDefaultTransition() || {} } = s || {};
+  n.transitionOverride && (o = n.transitionOverride);
+  const c = s ? () => Promise.all(ts(e, s, n)) : () => Promise.resolve(), i = e.variantChildren && e.variantChildren.size ? (a = 0) => {
+    const { delayChildren: l = 0, staggerChildren: u, staggerDirection: h } = o;
+    return uo(e, t, l + a, u, h, n);
+  } : () => Promise.resolve(), { when: r } = o;
+  if (r) {
+    const [a, l] = r === "beforeChildren" ? [c, i] : [i, c];
+    return a().then(() => l());
+  } else
+    return Promise.all([c(), i(n.delay)]);
+}
+function uo(e, t, n = 0, s = 0, o = 1, c) {
+  const i = [], r = (e.variantChildren.size - 1) * s, a = o === 1 ? (l = 0) => l * s : (l = 0) => r - l * s;
+  return Array.from(e.variantChildren).sort(ho).forEach((l, u) => {
+    l.notify("AnimationStart", t), i.push(Zt(l, t, {
+      ...c,
+      delay: n + a(u)
+    }).then(() => l.notify("AnimationComplete", t)));
+  }), Promise.all(i);
+}
+function ho(e, t) {
+  return e.sortNodePosition(t);
+}
+function fo(e, t, n = {}) {
+  e.notify("AnimationStart", t);
+  let s;
+  if (Array.isArray(t)) {
+    const o = t.map((c) => Zt(e, c, n));
+    s = Promise.all(o);
+  } else if (typeof t == "string")
+    s = Zt(e, t, n);
+  else {
+    const o = typeof t == "function" ? Bt(e, t, n.custom) : t;
+    s = Promise.all(ts(e, o, n));
+  }
+  return s.then(() => e.notify("AnimationComplete", t));
+}
+const po = [...xn].reverse(), mo = xn.length;
+function go(e) {
+  return (t) => Promise.all(t.map(({ animation: n, options: s }) => fo(e, n, s)));
+}
+function yo(e) {
+  let t = go(e);
+  const n = Po();
+  let s = !0;
+  const o = (a, l) => {
+    const u = Bt(e, l);
+    if (u) {
+      const { transition: h, transitionEnd: f, ...d } = u;
+      a = { ...a, ...d, ...f };
+    }
+    return a;
+  };
+  function c(a) {
+    t = a(e);
+  }
+  function i(a, l) {
+    const u = e.getProps(), h = e.getVariantContext(!0) || {}, f = [], d = /* @__PURE__ */ new Set();
+    let p = {}, m = 1 / 0;
+    for (let V = 0; V < mo; V++) {
+      const y = po[V], g = n[y], P = u[y] !== void 0 ? u[y] : h[y], x = Tn(P), F = y === l ? g.isActive : null;
+      F === !1 && (m = V);
+      let S = P === h[y] && P !== u[y] && x;
+      if (S && s && e.manuallyAnimateOnMount && (S = !1), g.protectedKeys = { ...p }, // If it isn't active and hasn't *just* been set as inactive
+      !g.isActive && F === null || // If we didn't and don't have any defined prop for this animation type
+      !P && !g.prevProp || // Or if the prop doesn't define an animation
+      Pn(P) || typeof P == "boolean")
+        continue;
+      const T = vo(g.prevProp, P);
+      let A = T || // If we're making this variant active, we want to always make it active
+      y === l && g.isActive && !S && x || // If we removed a higher-priority variant (i is in reverse order)
+      V > m && x;
+      const O = Array.isArray(P) ? P : [P];
+      let U = O.reduce(o, {});
+      F === !1 && (U = {});
+      const { prevResolvedValues: z = {} } = g, H = {
+        ...z,
+        ...U
+      }, L = (M) => {
+        A = !0, d.delete(M), g.needsAnimating[M] = !0;
+      };
+      for (const M in H) {
+        const _ = U[M], st = z[M];
+        p.hasOwnProperty(M) || (_ !== st ? $t(_) && $t(st) ? !jn(_, st) || T ? L(M) : g.protectedKeys[M] = !0 : _ !== void 0 ? L(M) : d.add(M) : _ !== void 0 && d.has(M) ? L(M) : g.protectedKeys[M] = !0);
+      }
+      g.prevProp = P, g.prevResolvedValues = U, g.isActive && (p = { ...p, ...U }), s && e.blockInitialAnimation && (A = !1), A && !S && f.push(...O.map((M) => ({
+        animation: M,
+        options: { type: y, ...a }
+      })));
+    }
+    if (d.size) {
+      const V = {};
+      d.forEach((y) => {
+        const g = e.getBaseTarget(y);
+        g !== void 0 && (V[y] = g);
+      }), f.push({ animation: V });
+    }
+    let v = !!f.length;
+    return s && u.initial === !1 && !e.manuallyAnimateOnMount && (v = !1), s = !1, v ? t(f) : Promise.resolve();
+  }
+  function r(a, l, u) {
+    var h;
+    if (n[a].isActive === l)
+      return Promise.resolve();
+    (h = e.variantChildren) === null || h === void 0 || h.forEach((d) => {
+      var p;
+      return (p = d.animationState) === null || p === void 0 ? void 0 : p.setActive(a, l);
+    }), n[a].isActive = l;
+    const f = i(u, a);
+    for (const d in n)
+      n[d].protectedKeys = {};
+    return f;
+  }
+  return {
+    animateChanges: i,
+    setActive: r,
+    setAnimateFunction: c,
+    getState: () => n
+  };
+}
+function vo(e, t) {
+  return typeof t == "string" ? t !== e : Array.isArray(t) ? !jn(t, e) : !1;
+}
+function Z(e = !1) {
+  return {
+    isActive: e,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function Po() {
+  return {
+    animate: Z(!0),
+    whileInView: Z(),
+    whileHover: Z(),
+    whileTap: Z(),
+    whileDrag: Z(),
+    whileFocus: Z(),
+    exit: Z()
+  };
+}
+class xo extends q {
+  /**
+   * 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(t) {
+    super(t), t.animationState || (t.animationState = yo(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    this.unmount(), Pn(t) && (this.unmount = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    t !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+  }
+}
+let To = 0;
+class Vo extends q {
+  constructor() {
+    super(...arguments), this.id = To++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: t, onExitComplete: n, custom: s } = this.node.presenceContext, { isPresent: o } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === o)
+      return;
+    const c = this.node.animationState.setActive("exit", !t, { custom: s ?? this.node.getProps().custom });
+    n && !t && c.then(() => n(this.id));
+  }
+  mount() {
+    const { register: t } = this.node.presenceContext || {};
+    t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+const So = {
+  animation: {
+    Feature: xo
+  },
+  exit: {
+    Feature: Vo
+  }
+}, Me = (e, t) => Math.abs(e - t);
+function bo(e, t) {
+  const n = Me(e.x, t.x), s = Me(e.y, t.y);
+  return Math.sqrt(n ** 2 + s ** 2);
+}
+class es {
+  constructor(t, n, { transformPagePoint: s } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const l = Nt(this.lastMoveEventInfo, this.history), u = this.startEvent !== null, h = bo(l.offset, { x: 0, y: 0 }) >= 3;
+      if (!u && !h)
+        return;
+      const { point: f } = l, { timestamp: d } = R;
+      this.history.push({ ...f, timestamp: d });
+      const { onStart: p, onMove: m } = this.handlers;
+      u || (p && p(this.lastMoveEvent, l), this.startEvent = this.lastMoveEvent), m && m(this.lastMoveEvent, l);
+    }, this.handlePointerMove = (l, u) => {
+      this.lastMoveEvent = l, this.lastMoveEventInfo = Ut(u, this.transformPagePoint), C.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (l, u) => {
+      if (this.end(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const { onEnd: h, onSessionEnd: f } = this.handlers, d = Nt(l.type === "pointercancel" ? this.lastMoveEventInfo : Ut(u, this.transformPagePoint), this.history);
+      this.startEvent && h && h(l, d), f && f(l, d);
+    }, !Ln(t))
+      return;
+    this.handlers = n, this.transformPagePoint = s;
+    const o = Rt(t), c = Ut(o, this.transformPagePoint), { point: i } = c, { timestamp: r } = R;
+    this.history = [{ ...i, timestamp: r }];
+    const { onSessionStart: a } = n;
+    a && a(t, Nt(c, this.history)), this.removeListeners = rt(G(window, "pointermove", this.handlePointerMove), G(window, "pointerup", this.handlePointerUp), G(window, "pointercancel", this.handlePointerUp));
+  }
+  updateHandlers(t) {
+    this.handlers = t;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), $(this.updatePoint);
+  }
+}
+function Ut(e, t) {
+  return t ? { point: t(e.point) } : e;
+}
+function we(e, t) {
+  return { x: e.x - t.x, y: e.y - t.y };
+}
+function Nt({ point: e }, t) {
+  return {
+    point: e,
+    delta: we(e, ns(t)),
+    offset: we(e, Ao(t)),
+    velocity: Do(t, 0.1)
+  };
+}
+function Ao(e) {
+  return e[0];
+}
+function ns(e) {
+  return e[e.length - 1];
+}
+function Do(e, t) {
+  if (e.length < 2)
+    return { x: 0, y: 0 };
+  let n = e.length - 1, s = null;
+  const o = ns(e);
+  for (; n >= 0 && (s = e[n], !(o.timestamp - s.timestamp > Y(t))); )
+    n--;
+  if (!s)
+    return { x: 0, y: 0 };
+  const c = K(o.timestamp - s.timestamp);
+  if (c === 0)
+    return { x: 0, y: 0 };
+  const i = {
+    x: (o.x - s.x) / c,
+    y: (o.y - s.y) / c
+  };
+  return i.x === 1 / 0 && (i.x = 0), i.y === 1 / 0 && (i.y = 0), i;
+}
+function E(e) {
+  return e.max - e.min;
+}
+function Jt(e, t = 0, n = 0.01) {
+  return Math.abs(e - t) <= n;
+}
+function Le(e, t, n, s = 0.5) {
+  e.origin = s, e.originPoint = w(t.min, t.max, e.origin), e.scale = E(n) / E(t), (Jt(e.scale, 1, 1e-4) || isNaN(e.scale)) && (e.scale = 1), e.translate = w(n.min, n.max, e.origin) - e.originPoint, (Jt(e.translate) || isNaN(e.translate)) && (e.translate = 0);
+}
+function mt(e, t, n, s) {
+  Le(e.x, t.x, n.x, s ? s.originX : void 0), Le(e.y, t.y, n.y, s ? s.originY : void 0);
+}
+function Re(e, t, n) {
+  e.min = n.min + t.min, e.max = e.min + E(t);
+}
+function Co(e, t, n) {
+  Re(e.x, t.x, n.x), Re(e.y, t.y, n.y);
+}
+function Be(e, t, n) {
+  e.min = t.min - n.min, e.max = e.min + E(t);
+}
+function gt(e, t, n) {
+  Be(e.x, t.x, n.x), Be(e.y, t.y, n.y);
+}
+function Mo(e, { min: t, max: n }, s) {
+  return t !== void 0 && e < t ? e = s ? w(t, e, s.min) : Math.max(e, t) : n !== void 0 && e > n && (e = s ? w(n, e, s.max) : Math.min(e, n)), e;
+}
+function Fe(e, t, n) {
+  return {
+    min: t !== void 0 ? e.min + t : void 0,
+    max: n !== void 0 ? e.max + n - (e.max - e.min) : void 0
+  };
+}
+function wo(e, { top: t, left: n, bottom: s, right: o }) {
+  return {
+    x: Fe(e.x, n, o),
+    y: Fe(e.y, t, s)
+  };
+}
+function Ee(e, t) {
+  let n = t.min - e.min, s = t.max - e.max;
+  return t.max - t.min < e.max - e.min && ([n, s] = [s, n]), { min: n, max: s };
+}
+function Lo(e, t) {
+  return {
+    x: Ee(e.x, t.x),
+    y: Ee(e.y, t.y)
+  };
+}
+function Ro(e, t) {
+  let n = 0.5;
+  const s = E(e), o = E(t);
+  return o > s ? n = zt(t.min, t.max - s, e.min) : s > o && (n = zt(e.min, e.max - o, t.min)), yt(0, 1, n);
+}
+function Bo(e, t) {
+  const n = {};
+  return t.min !== void 0 && (n.min = t.min - e.min), t.max !== void 0 && (n.max = t.max - e.min), n;
+}
+const Qt = 0.35;
+function Fo(e = Qt) {
+  return e === !1 ? e = 0 : e === !0 && (e = Qt), {
+    x: je(e, "left", "right"),
+    y: je(e, "top", "bottom")
+  };
+}
+function je(e, t, n) {
+  return {
+    min: ke(e, t),
+    max: ke(e, n)
+  };
+}
+function ke(e, t) {
+  return typeof e == "number" ? e : e[t] || 0;
+}
+const Ie = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), it = () => ({
+  x: Ie(),
+  y: Ie()
+}), Oe = () => ({ min: 0, max: 0 }), D = () => ({
+  x: Oe(),
+  y: Oe()
+});
+function I(e) {
+  return [e("x"), e("y")];
+}
+function ss({ top: e, left: t, right: n, bottom: s }) {
+  return {
+    x: { min: t, max: n },
+    y: { min: e, max: s }
+  };
+}
+function Eo({ x: e, y: t }) {
+  return { top: t.min, right: e.max, bottom: t.max, left: e.min };
+}
+function jo(e, t) {
+  if (!t)
+    return e;
+  const n = t({ x: e.left, y: e.top }), s = t({ x: e.right, y: e.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: s.y,
+    right: s.x
+  };
+}
+function Gt(e) {
+  return e === void 0 || e === 1;
+}
+function te({ scale: e, scaleX: t, scaleY: n }) {
+  return !Gt(e) || !Gt(t) || !Gt(n);
+}
+function J(e) {
+  return te(e) || is(e) || e.z || e.rotate || e.rotateX || e.rotateY;
+}
+function is(e) {
+  return Ue(e.x) || Ue(e.y);
+}
+function Ue(e) {
+  return e && e !== "0%";
+}
+function Lt(e, t, n) {
+  const s = e - n, o = t * s;
+  return n + o;
+}
+function Ne(e, t, n, s, o) {
+  return o !== void 0 && (e = Lt(e, o, s)), Lt(e, n, s) + t;
+}
+function ee(e, t = 0, n = 1, s, o) {
+  e.min = Ne(e.min, t, n, s, o), e.max = Ne(e.max, t, n, s, o);
+}
+function os(e, { x: t, y: n }) {
+  ee(e.x, t.translate, t.scale, t.originPoint), ee(e.y, n.translate, n.scale, n.originPoint);
+}
+function ko(e, t, n, s = !1) {
+  const o = n.length;
+  if (!o)
+    return;
+  t.x = t.y = 1;
+  let c, i;
+  for (let r = 0; r < o; r++) {
+    c = n[r], i = c.projectionDelta;
+    const a = c.instance;
+    a && a.style && a.style.display === "contents" || (s && c.options.layoutScroll && c.scroll && c !== c.root && ot(e, {
+      x: -c.scroll.offset.x,
+      y: -c.scroll.offset.y
+    }), i && (t.x *= i.x.scale, t.y *= i.y.scale, os(e, i)), s && J(c.latestValues) && ot(e, c.latestValues));
+  }
+  t.x = Ge(t.x), t.y = Ge(t.y);
+}
+function Ge(e) {
+  return Number.isInteger(e) || e > 1.0000000000001 || e < 0.999999999999 ? e : 1;
+}
+function W(e, t) {
+  e.min = e.min + t, e.max = e.max + t;
+}
+function Ke(e, t, [n, s, o]) {
+  const c = t[o] !== void 0 ? t[o] : 0.5, i = w(e.min, e.max, c);
+  ee(e, t[n], t[s], i, t.scale);
+}
+const Io = ["x", "scaleX", "originX"], Oo = ["y", "scaleY", "originY"];
+function ot(e, t) {
+  Ke(e.x, t, Io), Ke(e.y, t, Oo);
+}
+function rs(e, t) {
+  return ss(jo(e.getBoundingClientRect(), t));
+}
+function Uo(e, t, n) {
+  const s = rs(e, n), { scroll: o } = t;
+  return o && (W(s.x, o.offset.x), W(s.y, o.offset.y)), s;
+}
+const No = /* @__PURE__ */ new WeakMap();
+class Go {
+  constructor(t) {
+    this.openGlobalLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = D(), this.visualElement = t;
+  }
+  start(t, { snapToCursor: n = !1 } = {}) {
+    const { presenceContext: s } = this.visualElement;
+    if (s && s.isPresent === !1)
+      return;
+    const o = (a) => {
+      this.stopAnimation(), n && this.snapToCursor(Rt(a, "page").point);
+    }, c = (a, l) => {
+      const { drag: u, dragPropagation: h, onDragStart: f } = this.getProps();
+      if (u && !h && (this.openGlobalLock && this.openGlobalLock(), this.openGlobalLock = Bn(u), !this.openGlobalLock))
+        return;
+      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 m = this.getAxisMotionValue(p).get() || 0;
+        if (vt.test(m)) {
+          const { projection: v } = this.visualElement;
+          if (v && v.layout) {
+            const V = v.layout.layoutBox[p];
+            V && (m = E(V) * (parseFloat(m) / 100));
+          }
+        }
+        this.originPoint[p] = m;
+      }), f && C.update(() => f(a, l), !1, !0);
+      const { animationState: d } = this.visualElement;
+      d && d.setActive("whileDrag", !0);
+    }, i = (a, l) => {
+      const { dragPropagation: u, dragDirectionLock: h, onDirectionLock: f, onDrag: d } = this.getProps();
+      if (!u && !this.openGlobalLock)
+        return;
+      const { offset: p } = l;
+      if (h && this.currentDirection === null) {
+        this.currentDirection = Ko(p), this.currentDirection !== null && f && f(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", l.point, p), this.updateAxis("y", l.point, p), this.visualElement.render(), d && d(a, l);
+    }, r = (a, l) => this.stop(a, l);
+    this.panSession = new es(t, {
+      onSessionStart: o,
+      onStart: c,
+      onMove: i,
+      onSessionEnd: r
+    }, { transformPagePoint: this.visualElement.getTransformPagePoint() });
+  }
+  stop(t, n) {
+    const s = this.isDragging;
+    if (this.cancel(), !s)
+      return;
+    const { velocity: o } = n;
+    this.startAnimation(o);
+    const { onDragEnd: c } = this.getProps();
+    c && C.update(() => c(t, n));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: n } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.panSession && this.panSession.end(), this.panSession = void 0;
+    const { dragPropagation: s } = this.getProps();
+    !s && this.openGlobalLock && (this.openGlobalLock(), this.openGlobalLock = null), n && n.setActive("whileDrag", !1);
+  }
+  updateAxis(t, n, s) {
+    const { drag: o } = this.getProps();
+    if (!s || !bt(t, o, this.currentDirection))
+      return;
+    const c = this.getAxisMotionValue(t);
+    let i = this.originPoint[t] + s[t];
+    this.constraints && this.constraints[t] && (i = Mo(i, this.constraints[t], this.elastic[t])), c.set(i);
+  }
+  resolveConstraints() {
+    const { dragConstraints: t, dragElastic: n } = this.getProps(), { layout: s } = this.visualElement.projection || {}, o = this.constraints;
+    t && dt(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && s ? this.constraints = wo(s.layoutBox, t) : this.constraints = !1, this.elastic = Fo(n), o !== this.constraints && s && this.constraints && !this.hasMutatedConstraints && I((c) => {
+      this.getAxisMotionValue(c) && (this.constraints[c] = Bo(s.layoutBox[c], this.constraints[c]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: n } = this.getProps();
+    if (!t || !dt(t))
+      return !1;
+    const s = t.current;
+    tt(s !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
+    const { projection: o } = this.visualElement;
+    if (!o || !o.layout)
+      return !1;
+    const c = Uo(s, o.root, this.visualElement.getTransformPagePoint());
+    let i = Lo(o.layout.layoutBox, c);
+    if (n) {
+      const r = n(Eo(i));
+      this.hasMutatedConstraints = !!r, r && (i = ss(r));
+    }
+    return i;
+  }
+  startAnimation(t) {
+    const { drag: n, dragMomentum: s, dragElastic: o, dragTransition: c, dragSnapToOrigin: i, onDragTransitionEnd: r } = this.getProps(), a = this.constraints || {}, l = I((u) => {
+      if (!bt(u, n, this.currentDirection))
+        return;
+      let h = a && a[u] || {};
+      i && (h = { min: 0, max: 0 });
+      const f = o ? 200 : 1e6, d = o ? 40 : 1e7, p = {
+        type: "inertia",
+        velocity: s ? t[u] : 0,
+        bounceStiffness: f,
+        bounceDamping: d,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...c,
+        ...h
+      };
+      return this.startAxisValueAnimation(u, p);
+    });
+    return Promise.all(l).then(r);
+  }
+  startAxisValueAnimation(t, n) {
+    const s = this.getAxisMotionValue(t);
+    return s.start(le(t, s, 0, n));
+  }
+  stopAnimation() {
+    I((t) => this.getAxisMotionValue(t).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(t) {
+    const n = "_drag" + t.toUpperCase(), s = this.visualElement.getProps(), o = s[n];
+    return o || this.visualElement.getValue(t, (s.initial ? s.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    I((n) => {
+      const { drag: s } = this.getProps();
+      if (!bt(n, s, this.currentDirection))
+        return;
+      const { projection: o } = this.visualElement, c = this.getAxisMotionValue(n);
+      if (o && o.layout) {
+        const { min: i, max: r } = o.layout.layoutBox[n];
+        c.set(t[n] - w(i, r, 0.5));
+      }
+    });
+  }
+  /**
+   * 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: t, dragConstraints: n } = this.getProps(), { projection: s } = this.visualElement;
+    if (!dt(n) || !s || !this.constraints)
+      return;
+    this.stopAnimation();
+    const o = { x: 0, y: 0 };
+    I((i) => {
+      const r = this.getAxisMotionValue(i);
+      if (r) {
+        const a = r.get();
+        o[i] = Ro({ min: a, max: a }, this.constraints[i]);
+      }
+    });
+    const { transformTemplate: c } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = c ? c({}, "") : "none", s.root && s.root.updateScroll(), s.updateLayout(), this.resolveConstraints(), I((i) => {
+      if (!bt(i, t, null))
+        return;
+      const r = this.getAxisMotionValue(i), { min: a, max: l } = this.constraints[i];
+      r.set(w(a, l, o[i]));
+    });
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    No.set(this.visualElement, this);
+    const t = this.visualElement.current, n = G(t, "pointerdown", (a) => {
+      const { drag: l, dragListener: u = !0 } = this.getProps();
+      l && u && this.start(a);
+    }), s = () => {
+      const { dragConstraints: a } = this.getProps();
+      dt(a) && (this.constraints = this.resolveRefConstraints());
+    }, { projection: o } = this.visualElement, c = o.addEventListener("measure", s);
+    o && !o.layout && (o.root && o.root.updateScroll(), o.updateLayout()), s();
+    const i = N(window, "resize", () => this.scalePositionWithinConstraints()), r = o.addEventListener("didUpdate", ({ delta: a, hasLayoutChanged: l }) => {
+      this.isDragging && l && (I((u) => {
+        const h = this.getAxisMotionValue(u);
+        h && (this.originPoint[u] += a[u].translate, h.set(h.get() + a[u].translate));
+      }), this.visualElement.render());
+    });
+    return () => {
+      i(), n(), c(), r && r();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: n = !1, dragDirectionLock: s = !1, dragPropagation: o = !1, dragConstraints: c = !1, dragElastic: i = Qt, dragMomentum: r = !0 } = t;
+    return {
+      ...t,
+      drag: n,
+      dragDirectionLock: s,
+      dragPropagation: o,
+      dragConstraints: c,
+      dragElastic: i,
+      dragMomentum: r
+    };
+  }
+}
+function bt(e, t, n) {
+  return (t === !0 || t === e) && (n === null || n === e);
+}
+function Ko(e, t = 10) {
+  let n = null;
+  return Math.abs(e.y) > t ? n = "y" : Math.abs(e.x) > t && (n = "x"), n;
+}
+class $o extends q {
+  constructor(t) {
+    super(t), this.removeGroupControls = B, this.removeListeners = B, this.controls = new Go(t);
+  }
+  mount() {
+    const { dragControls: t } = this.node.getProps();
+    t && (this.removeGroupControls = t.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || B;
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners();
+  }
+}
+const $e = (e) => (t, n) => {
+  e && C.update(() => e(t, n));
+};
+class zo extends q {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = B;
+  }
+  onPointerDown(t) {
+    this.session = new es(t, this.createPanHandlers(), { transformPagePoint: this.node.getTransformPagePoint() });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: t, onPanStart: n, onPan: s, onPanEnd: o } = this.node.getProps();
+    return {
+      onSessionStart: $e(t),
+      onStart: $e(n),
+      onMove: s,
+      onEnd: (c, i) => {
+        delete this.session, o && C.update(() => o(c, i));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = G(this.node.current, "pointerdown", (t) => this.onPointerDown(t));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+}
+function Ho() {
+  const e = _t(ws);
+  if (e === null)
+    return [!0, null];
+  const { isPresent: t, onExitComplete: n, register: s } = e, o = _s();
+  return Ws(() => s(o), []), !t && n ? [!1, () => n && n(o)] : [!0];
+}
+const Dt = {
+  /**
+   * 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
+};
+function ze(e, t) {
+  return t.max === t.min ? 0 : e / (t.max - t.min) * 100;
+}
+const ft = {
+  correct: (e, t) => {
+    if (!t.target)
+      return e;
+    if (typeof e == "string")
+      if (xt.test(e))
+        e = parseFloat(e);
+      else
+        return e;
+    const n = ze(e, t.target.x), s = ze(e, t.target.y);
+    return `${n}% ${s}%`;
+  }
+}, _o = {
+  correct: (e, { treeScale: t, projectionDelta: n }) => {
+    const s = e, o = et.parse(e);
+    if (o.length > 5)
+      return s;
+    const c = et.createTransformer(e), i = typeof o[0] != "number" ? 1 : 0, r = n.x.scale * t.x, a = n.y.scale * t.y;
+    o[0 + i] /= r, o[1 + i] /= a;
+    const l = w(r, a, 0.5);
+    return typeof o[2 + i] == "number" && (o[2 + i] /= l), typeof o[3 + i] == "number" && (o[3 + i] /= l), c(o);
+  }
+};
+class Wo extends wn.Component {
+  /**
+   * 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: t, layoutGroup: n, switchLayoutGroup: s, layoutId: o } = this.props, { projection: c } = t;
+    Ls(Yo), c && (n.group && n.group.add(c), s && s.register && o && s.register(c), c.root.didUpdate(), c.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), c.setOptions({
+      ...c.options,
+      onExitComplete: () => this.safeToRemove()
+    })), Dt.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(t) {
+    const { layoutDependency: n, visualElement: s, drag: o, isPresent: c } = this.props, i = s.projection;
+    return i && (i.isPresent = c, o || t.layoutDependency !== n || n === void 0 ? i.willUpdate() : this.safeToRemove(), t.isPresent !== c && (c ? i.promote() : i.relegate() || C.postRender(() => {
+      const r = i.getStack();
+      (!r || !r.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { projection: t } = this.props.visualElement;
+    t && (t.root.didUpdate(), queueMicrotask(() => {
+      !t.currentAnimation && t.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: t, layoutGroup: n, switchLayoutGroup: s } = this.props, { projection: o } = t;
+    o && (o.scheduleCheckAfterUnmount(), n && n.group && n.group.remove(o), s && s.deregister && s.deregister(o));
+  }
+  safeToRemove() {
+    const { safeToRemove: t } = this.props;
+    t && t();
+  }
+  render() {
+    return null;
+  }
+}
+function as(e) {
+  const [t, n] = Ho(), s = _t(Rs);
+  return wn.createElement(Wo, { ...e, layoutGroup: s, switchLayoutGroup: _t(Bs), isPresent: t, safeToRemove: n });
+}
+const Yo = {
+  borderRadius: {
+    ...ft,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: ft,
+  borderTopRightRadius: ft,
+  borderBottomLeftRadius: ft,
+  borderBottomRightRadius: ft,
+  boxShadow: _o
+}, ls = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"], qo = ls.length, He = (e) => typeof e == "string" ? parseFloat(e) : e, _e = (e) => typeof e == "number" || xt.test(e);
+function Xo(e, t, n, s, o, c) {
+  o ? (e.opacity = w(
+    0,
+    // TODO Reinstate this if only child
+    n.opacity !== void 0 ? n.opacity : 1,
+    Zo(s)
+  ), e.opacityExit = w(t.opacity !== void 0 ? t.opacity : 1, 0, Jo(s))) : c && (e.opacity = w(t.opacity !== void 0 ? t.opacity : 1, n.opacity !== void 0 ? n.opacity : 1, s));
+  for (let i = 0; i < qo; i++) {
+    const r = `border${ls[i]}Radius`;
+    let a = We(t, r), l = We(n, r);
+    if (a === void 0 && l === void 0)
+      continue;
+    a || (a = 0), l || (l = 0), a === 0 || l === 0 || _e(a) === _e(l) ? (e[r] = Math.max(w(He(a), He(l), s), 0), (vt.test(l) || vt.test(a)) && (e[r] += "%")) : e[r] = l;
+  }
+  (t.rotate || n.rotate) && (e.rotate = w(t.rotate || 0, n.rotate || 0, s));
+}
+function We(e, t) {
+  return e[t] !== void 0 ? e[t] : e.borderRadius;
+}
+const Zo = cs(0, 0.5, oe), Jo = cs(0.5, 0.95, B);
+function cs(e, t, n) {
+  return (s) => s < e ? 0 : s > t ? 1 : n(zt(e, t, s));
+}
+function Ye(e, t) {
+  e.min = t.min, e.max = t.max;
+}
+function j(e, t) {
+  Ye(e.x, t.x), Ye(e.y, t.y);
+}
+function qe(e, t, n, s, o) {
+  return e -= t, e = Lt(e, 1 / n, s), o !== void 0 && (e = Lt(e, 1 / o, s)), e;
+}
+function Qo(e, t = 0, n = 1, s = 0.5, o, c = e, i = e) {
+  if (vt.test(t) && (t = parseFloat(t), t = w(i.min, i.max, t / 100) - i.min), typeof t != "number")
+    return;
+  let r = w(c.min, c.max, s);
+  e === c && (r -= t), e.min = qe(e.min, t, n, r, o), e.max = qe(e.max, t, n, r, o);
+}
+function Xe(e, t, [n, s, o], c, i) {
+  Qo(e, t[n], t[s], t[o], t.scale, c, i);
+}
+const tr = ["x", "scaleX", "originX"], er = ["y", "scaleY", "originY"];
+function Ze(e, t, n, s) {
+  Xe(e.x, t, tr, n ? n.x : void 0, s ? s.x : void 0), Xe(e.y, t, er, n ? n.y : void 0, s ? s.y : void 0);
+}
+function Je(e) {
+  return e.translate === 0 && e.scale === 1;
+}
+function us(e) {
+  return Je(e.x) && Je(e.y);
+}
+function nr(e, t) {
+  return e.x.min === t.x.min && e.x.max === t.x.max && e.y.min === t.y.min && e.y.max === t.y.max;
+}
+function hs(e, t) {
+  return Math.round(e.x.min) === Math.round(t.x.min) && Math.round(e.x.max) === Math.round(t.x.max) && Math.round(e.y.min) === Math.round(t.y.min) && Math.round(e.y.max) === Math.round(t.y.max);
+}
+function Qe(e) {
+  return E(e.x) / E(e.y);
+}
+class sr {
+  constructor() {
+    this.members = [];
+  }
+  add(t) {
+    Vn(this.members, t), t.scheduleRender();
+  }
+  remove(t) {
+    if (Sn(this.members, t), t === this.prevLead && (this.prevLead = void 0), t === this.lead) {
+      const n = this.members[this.members.length - 1];
+      n && this.promote(n);
+    }
+  }
+  relegate(t) {
+    const n = this.members.findIndex((o) => t === o);
+    if (n === 0)
+      return !1;
+    let s;
+    for (let o = n; o >= 0; o--) {
+      const c = this.members[o];
+      if (c.isPresent !== !1) {
+        s = c;
+        break;
+      }
+    }
+    return s ? (this.promote(s), !0) : !1;
+  }
+  promote(t, n) {
+    const s = this.lead;
+    if (t !== s && (this.prevLead = s, this.lead = t, t.show(), s)) {
+      s.instance && s.scheduleRender(), t.scheduleRender(), t.resumeFrom = s, n && (t.resumeFrom.preserveOpacity = !0), s.snapshot && (t.snapshot = s.snapshot, t.snapshot.latestValues = s.animationValues || s.latestValues), t.root && t.root.isUpdating && (t.isLayoutDirty = !0);
+      const { crossfade: o } = t.options;
+      o === !1 && s.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((t) => {
+      const { options: n, resumingFrom: s } = t;
+      n.onExitComplete && n.onExitComplete(), s && s.options.onExitComplete && s.options.onExitComplete();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((t) => {
+      t.instance && t.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);
+  }
+}
+function tn(e, t, n) {
+  let s = "";
+  const o = e.x.translate / t.x, c = e.y.translate / t.y;
+  if ((o || c) && (s = `translate3d(${o}px, ${c}px, 0) `), (t.x !== 1 || t.y !== 1) && (s += `scale(${1 / t.x}, ${1 / t.y}) `), n) {
+    const { rotate: a, rotateX: l, rotateY: u } = n;
+    a && (s += `rotate(${a}deg) `), l && (s += `rotateX(${l}deg) `), u && (s += `rotateY(${u}deg) `);
+  }
+  const i = e.x.scale * t.x, r = e.y.scale * t.y;
+  return (i !== 1 || r !== 1) && (s += `scale(${i}, ${r})`), s || "none";
+}
+const ir = (e, t) => e.depth - t.depth;
+class or {
+  constructor() {
+    this.children = [], this.isDirty = !1;
+  }
+  add(t) {
+    Vn(this.children, t), this.isDirty = !0;
+  }
+  remove(t) {
+    Sn(this.children, t), this.isDirty = !0;
+  }
+  forEach(t) {
+    this.isDirty && this.children.sort(ir), this.isDirty = !1, this.children.forEach(t);
+  }
+}
+function rr(e, t) {
+  const n = performance.now(), s = ({ timestamp: o }) => {
+    const c = o - n;
+    c >= t && ($(s), e(c - t));
+  };
+  return C.read(s, !0), () => $(s);
+}
+function ar(e) {
+  window.MotionDebug && window.MotionDebug.record(e);
+}
+function lr(e) {
+  return e instanceof SVGElement && e.tagName !== "svg";
+}
+function cr(e, t, n) {
+  const s = nt(e) ? e : at(e);
+  return s.start(le("", s, t, n)), s.animation;
+}
+const en = ["", "X", "Y", "Z"], nn = 1e3;
+let ur = 0;
+const Q = {
+  type: "projectionFrame",
+  totalNodes: 0,
+  resolvedTargetDeltas: 0,
+  recalculatedProjection: 0
+};
+function fs({ attachResizeListener: e, defaultParent: t, measureScroll: n, checkIsScrollRoot: s, resetTransform: o }) {
+  return class {
+    constructor(i = {}, r = t == null ? void 0 : t()) {
+      this.id = ur++, this.animationId = 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.treeScale = { x: 1, y: 1 }, this.eventHandlers = /* @__PURE__ */ new Map(), this.hasTreeAnimated = !1, this.updateScheduled = !1, this.checkUpdateFailed = () => {
+        this.isUpdating && (this.isUpdating = !1, this.clearAllSnapshots());
+      }, this.updateProjection = () => {
+        Q.totalNodes = Q.resolvedTargetDeltas = Q.recalculatedProjection = 0, this.nodes.forEach(dr), this.nodes.forEach(vr), this.nodes.forEach(Pr), this.nodes.forEach(pr), ar(Q);
+      }, this.hasProjected = !1, this.isVisible = !0, this.animationProgress = 0, this.sharedNodes = /* @__PURE__ */ new Map(), this.latestValues = i, 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 a = 0; a < this.path.length; a++)
+        this.path[a].shouldResetTransform = !0;
+      this.root === this && (this.nodes = new or());
+    }
+    addEventListener(i, r) {
+      return this.eventHandlers.has(i) || this.eventHandlers.set(i, new bn()), this.eventHandlers.get(i).add(r);
+    }
+    notifyListeners(i, ...r) {
+      const a = this.eventHandlers.get(i);
+      a && a.notify(...r);
+    }
+    hasListeners(i) {
+      return this.eventHandlers.has(i);
+    }
+    /**
+     * Lifecycles
+     */
+    mount(i, r = this.root.hasTreeAnimated) {
+      if (this.instance)
+        return;
+      this.isSVG = lr(i), this.instance = i;
+      const { layoutId: a, layout: l, visualElement: u } = this.options;
+      if (u && !u.current && u.mount(i), this.root.nodes.add(this), this.parent && this.parent.children.add(this), r && (l || a) && (this.isLayoutDirty = !0), e) {
+        let h;
+        const f = () => this.root.updateBlockedByResize = !1;
+        e(i, () => {
+          this.root.updateBlockedByResize = !0, h && h(), h = rr(f, 250), Dt.hasAnimatedSinceResize && (Dt.hasAnimatedSinceResize = !1, this.nodes.forEach(on));
+        });
+      }
+      a && this.root.registerSharedNode(a, this), this.options.animate !== !1 && u && (a || l) && this.addEventListener("didUpdate", ({ delta: h, hasLayoutChanged: f, hasRelativeTargetChanged: d, layout: p }) => {
+        if (this.isTreeAnimationBlocked()) {
+          this.target = void 0, this.relativeTarget = void 0;
+          return;
+        }
+        const m = this.options.transition || u.getDefaultTransition() || br, { onLayoutAnimationStart: v, onLayoutAnimationComplete: V } = u.getProps(), y = !this.targetLayout || !hs(this.targetLayout, p) || d, g = !f && d;
+        if (this.options.layoutRoot || this.resumeFrom && this.resumeFrom.instance || g || f && (y || !this.currentAnimation)) {
+          this.resumeFrom && (this.resumingFrom = this.resumeFrom, this.resumingFrom.resumingFrom = void 0), this.setAnimationOrigin(h, g);
+          const P = {
+            ...Xn(m, "layout"),
+            onPlay: v,
+            onComplete: V
+          };
+          (u.shouldReduceMotion || this.options.layoutRoot) && (P.delay = 0, P.type = !1), this.startAnimation(P);
+        } else
+          f || on(this), this.isLead() && this.options.onExitComplete && this.options.onExitComplete();
+        this.targetLayout = p;
+      });
+    }
+    unmount() {
+      this.options.layoutId && this.willUpdate(), this.root.nodes.remove(this);
+      const i = this.getStack();
+      i && i.remove(this), this.parent && this.parent.children.delete(this), this.instance = void 0, $(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(xr), this.animationId++);
+    }
+    getTransformTemplate() {
+      const { visualElement: i } = this.options;
+      return i && i.getProps().transformTemplate;
+    }
+    willUpdate(i = !0) {
+      if (this.root.hasTreeAnimated = !0, this.root.isUpdateBlocked()) {
+        this.options.onExitComplete && this.options.onExitComplete();
+        return;
+      }
+      if (!this.root.isUpdating && this.root.startUpdate(), this.isLayoutDirty)
+        return;
+      this.isLayoutDirty = !0;
+      for (let u = 0; u < this.path.length; u++) {
+        const h = this.path[u];
+        h.shouldResetTransform = !0, h.updateScroll("snapshot"), h.options.layoutRoot && h.willUpdate(!1);
+      }
+      const { layoutId: r, layout: a } = this.options;
+      if (r === void 0 && !a)
+        return;
+      const l = this.getTransformTemplate();
+      this.prevTransformTemplateValue = l ? l(this.latestValues, "") : void 0, this.updateSnapshot(), i && this.notifyListeners("willUpdate");
+    }
+    update() {
+      if (this.updateScheduled = !1, this.isUpdateBlocked()) {
+        this.unblockUpdate(), this.clearAllSnapshots(), this.nodes.forEach(sn);
+        return;
+      }
+      this.isUpdating || this.nodes.forEach(gr), this.isUpdating = !1, this.nodes.forEach(yr), this.nodes.forEach(hr), this.nodes.forEach(fr), this.clearAllSnapshots();
+      const r = performance.now();
+      R.delta = yt(0, 1e3 / 60, r - R.timestamp), R.timestamp = r, R.isProcessing = !0, Et.update.process(R), Et.preRender.process(R), Et.render.process(R), R.isProcessing = !1;
+    }
+    didUpdate() {
+      this.updateScheduled || (this.updateScheduled = !0, queueMicrotask(() => this.update()));
+    }
+    clearAllSnapshots() {
+      this.nodes.forEach(mr), this.sharedNodes.forEach(Tr);
+    }
+    scheduleUpdateProjection() {
+      C.preRender(this.updateProjection, !1, !0);
+    }
+    scheduleCheckAfterUnmount() {
+      C.postRender(() => {
+        this.isLayoutDirty ? this.root.didUpdate() : this.root.checkUpdateFailed();
+      });
+    }
+    /**
+     * Update measurements
+     */
+    updateSnapshot() {
+      this.snapshot || !this.instance || (this.snapshot = this.measure());
+    }
+    updateLayout() {
+      if (!this.instance || (this.updateScroll(), !(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty))
+        return;
+      if (this.resumeFrom && !this.resumeFrom.instance)
+        for (let a = 0; a < this.path.length; a++)
+          this.path[a].updateScroll();
+      const i = this.layout;
+      this.layout = this.measure(!1), this.layoutCorrected = D(), 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, i ? i.layoutBox : void 0);
+    }
+    updateScroll(i = "measure") {
+      let r = !!(this.options.layoutScroll && this.instance);
+      this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === i && (r = !1), r && (this.scroll = {
+        animationId: this.root.animationId,
+        phase: i,
+        isRoot: s(this.instance),
+        offset: n(this.instance)
+      });
+    }
+    resetTransform() {
+      if (!o)
+        return;
+      const i = this.isLayoutDirty || this.shouldResetTransform, r = this.projectionDelta && !us(this.projectionDelta), a = this.getTransformTemplate(), l = a ? a(this.latestValues, "") : void 0, u = l !== this.prevTransformTemplateValue;
+      i && (r || J(this.latestValues) || u) && (o(this.instance, l), this.shouldResetTransform = !1, this.scheduleRender());
+    }
+    measure(i = !0) {
+      const r = this.measurePageBox();
+      let a = this.removeElementScroll(r);
+      return i && (a = this.removeTransform(a)), Ar(a), {
+        animationId: this.root.animationId,
+        measuredBox: r,
+        layoutBox: a,
+        latestValues: {},
+        source: this.id
+      };
+    }
+    measurePageBox() {
+      const { visualElement: i } = this.options;
+      if (!i)
+        return D();
+      const r = i.measureViewportBox(), { scroll: a } = this.root;
+      return a && (W(r.x, a.offset.x), W(r.y, a.offset.y)), r;
+    }
+    removeElementScroll(i) {
+      const r = D();
+      j(r, i);
+      for (let a = 0; a < this.path.length; a++) {
+        const l = this.path[a], { scroll: u, options: h } = l;
+        if (l !== this.root && u && h.layoutScroll) {
+          if (u.isRoot) {
+            j(r, i);
+            const { scroll: f } = this.root;
+            f && (W(r.x, -f.offset.x), W(r.y, -f.offset.y));
+          }
+          W(r.x, u.offset.x), W(r.y, u.offset.y);
+        }
+      }
+      return r;
+    }
+    applyTransform(i, r = !1) {
+      const a = D();
+      j(a, i);
+      for (let l = 0; l < this.path.length; l++) {
+        const u = this.path[l];
+        !r && u.options.layoutScroll && u.scroll && u !== u.root && ot(a, {
+          x: -u.scroll.offset.x,
+          y: -u.scroll.offset.y
+        }), J(u.latestValues) && ot(a, u.latestValues);
+      }
+      return J(this.latestValues) && ot(a, this.latestValues), a;
+    }
+    removeTransform(i) {
+      const r = D();
+      j(r, i);
+      for (let a = 0; a < this.path.length; a++) {
+        const l = this.path[a];
+        if (!l.instance || !J(l.latestValues))
+          continue;
+        te(l.latestValues) && l.updateSnapshot();
+        const u = D(), h = l.measurePageBox();
+        j(u, h), Ze(r, l.latestValues, l.snapshot ? l.snapshot.layoutBox : void 0, u);
+      }
+      return J(this.latestValues) && Ze(r, this.latestValues), r;
+    }
+    setTargetDelta(i) {
+      this.targetDelta = i, this.root.scheduleUpdateProjection(), this.isProjectionDirty = !0;
+    }
+    setOptions(i) {
+      this.options = {
+        ...this.options,
+        ...i,
+        crossfade: i.crossfade !== void 0 ? i.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(i = !1) {
+      var r;
+      const a = this.getLead();
+      this.isProjectionDirty || (this.isProjectionDirty = a.isProjectionDirty), this.isTransformDirty || (this.isTransformDirty = a.isTransformDirty), this.isSharedProjectionDirty || (this.isSharedProjectionDirty = a.isSharedProjectionDirty);
+      const l = !!this.resumingFrom || this !== a;
+      if (!(i || l && this.isSharedProjectionDirty || this.isProjectionDirty || !((r = this.parent) === null || r === void 0) && r.isProjectionDirty || this.attemptToResolveRelativeTarget))
+        return;
+      const { layout: h, layoutId: f } = this.options;
+      if (!(!this.layout || !(h || f))) {
+        if (this.resolvedRelativeTargetAt = R.timestamp, !this.targetDelta && !this.relativeTarget) {
+          const d = this.getClosestProjectingParent();
+          d && d.layout && this.animationProgress !== 1 ? (this.relativeParent = d, this.forceRelativeParentToResolveTarget(), this.relativeTarget = D(), this.relativeTargetOrigin = D(), gt(this.relativeTargetOrigin, this.layout.layoutBox, d.layout.layoutBox), j(this.relativeTarget, this.relativeTargetOrigin)) : this.relativeParent = this.relativeTarget = void 0;
+        }
+        if (!(!this.relativeTarget && !this.targetDelta)) {
+          if (this.target || (this.target = D(), this.targetWithTransforms = D()), this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target ? (this.forceRelativeParentToResolveTarget(), Co(this.target, this.relativeTarget, this.relativeParent.target)) : this.targetDelta ? (this.resumingFrom ? this.target = this.applyTransform(this.layout.layoutBox) : j(this.target, this.layout.layoutBox), os(this.target, this.targetDelta)) : j(this.target, this.layout.layoutBox), this.attemptToResolveRelativeTarget) {
+            this.attemptToResolveRelativeTarget = !1;
+            const d = this.getClosestProjectingParent();
+            d && !!d.resumingFrom == !!this.resumingFrom && !d.options.layoutScroll && d.target && this.animationProgress !== 1 ? (this.relativeParent = d, this.forceRelativeParentToResolveTarget(), this.relativeTarget = D(), this.relativeTargetOrigin = D(), gt(this.relativeTargetOrigin, this.target, d.target), j(this.relativeTarget, this.relativeTargetOrigin)) : this.relativeParent = this.relativeTarget = void 0;
+          }
+          Q.resolvedTargetDeltas++;
+        }
+      }
+    }
+    getClosestProjectingParent() {
+      if (!(!this.parent || te(this.parent.latestValues) || is(this.parent.latestValues)))
+        return this.parent.isProjecting() ? this.parent : this.parent.getClosestProjectingParent();
+    }
+    isProjecting() {
+      return !!((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
+    }
+    calcProjection() {
+      var i;
+      const r = this.getLead(), a = !!this.resumingFrom || this !== r;
+      let l = !0;
+      if ((this.isProjectionDirty || !((i = this.parent) === null || i === void 0) && i.isProjectionDirty) && (l = !1), a && (this.isSharedProjectionDirty || this.isTransformDirty) && (l = !1), this.resolvedRelativeTargetAt === R.timestamp && (l = !1), l)
+        return;
+      const { layout: u, layoutId: h } = this.options;
+      if (this.isTreeAnimating = !!(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation), this.isTreeAnimating || (this.targetDelta = this.relativeTarget = void 0), !this.layout || !(u || h))
+        return;
+      j(this.layoutCorrected, this.layout.layoutBox);
+      const f = this.treeScale.x, d = this.treeScale.y;
+      ko(this.layoutCorrected, this.treeScale, this.path, a), r.layout && !r.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1) && (r.target = r.layout.layoutBox);
+      const { target: p } = r;
+      if (!p) {
+        this.projectionTransform && (this.projectionDelta = it(), this.projectionTransform = "none", this.scheduleRender());
+        return;
+      }
+      this.projectionDelta || (this.projectionDelta = it(), this.projectionDeltaWithTransform = it());
+      const m = this.projectionTransform;
+      mt(this.projectionDelta, this.layoutCorrected, p, this.latestValues), this.projectionTransform = tn(this.projectionDelta, this.treeScale), (this.projectionTransform !== m || this.treeScale.x !== f || this.treeScale.y !== d) && (this.hasProjected = !0, this.scheduleRender(), this.notifyListeners("projectionUpdate", p)), Q.recalculatedProjection++;
+    }
+    hide() {
+      this.isVisible = !1;
+    }
+    show() {
+      this.isVisible = !0;
+    }
+    scheduleRender(i = !0) {
+      if (this.options.scheduleRender && this.options.scheduleRender(), i) {
+        const r = this.getStack();
+        r && r.scheduleRender();
+      }
+      this.resumingFrom && !this.resumingFrom.instance && (this.resumingFrom = void 0);
+    }
+    setAnimationOrigin(i, r = !1) {
+      const a = this.snapshot, l = a ? a.latestValues : {}, u = { ...this.latestValues }, h = it();
+      (!this.relativeParent || !this.relativeParent.options.layoutRoot) && (this.relativeTarget = this.relativeTargetOrigin = void 0), this.attemptToResolveRelativeTarget = !r;
+      const f = D(), d = a ? a.source : void 0, p = this.layout ? this.layout.source : void 0, m = d !== p, v = this.getStack(), V = !v || v.members.length <= 1, y = !!(m && !V && this.options.crossfade === !0 && !this.path.some(Sr));
+      this.animationProgress = 0;
+      let g;
+      this.mixTargetDelta = (P) => {
+        const x = P / 1e3;
+        rn(h.x, i.x, x), rn(h.y, i.y, x), this.setTargetDelta(h), this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout && (gt(f, this.layout.layoutBox, this.relativeParent.layout.layoutBox), Vr(this.relativeTarget, this.relativeTargetOrigin, f, x), g && nr(this.relativeTarget, g) && (this.isProjectionDirty = !1), g || (g = D()), j(g, this.relativeTarget)), m && (this.animationValues = u, Xo(u, l, this.latestValues, x, y, V)), this.root.scheduleUpdateProjection(), this.scheduleRender(), this.animationProgress = x;
+      }, this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
+    }
+    startAnimation(i) {
+      this.notifyListeners("animationStart"), this.currentAnimation && this.currentAnimation.stop(), this.resumingFrom && this.resumingFrom.currentAnimation && this.resumingFrom.currentAnimation.stop(), this.pendingAnimation && ($(this.pendingAnimation), this.pendingAnimation = void 0), this.pendingAnimation = C.update(() => {
+        Dt.hasAnimatedSinceResize = !0, this.currentAnimation = cr(0, nn, {
+          ...i,
+          onUpdate: (r) => {
+            this.mixTargetDelta(r), i.onUpdate && i.onUpdate(r);
+          },
+          onComplete: () => {
+            i.onComplete && i.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 i = this.getStack();
+      i && i.exitAnimationComplete(), this.resumingFrom = this.currentAnimation = this.animationValues = void 0, this.notifyListeners("animationComplete");
+    }
+    finishAnimation() {
+      this.currentAnimation && (this.mixTargetDelta && this.mixTargetDelta(nn), this.currentAnimation.stop()), this.completeAnimation();
+    }
+    applyTransformsToTarget() {
+      const i = this.getLead();
+      let { targetWithTransforms: r, target: a, layout: l, latestValues: u } = i;
+      if (!(!r || !a || !l)) {
+        if (this !== i && this.layout && l && ds(this.options.animationType, this.layout.layoutBox, l.layoutBox)) {
+          a = this.target || D();
+          const h = E(this.layout.layoutBox.x);
+          a.x.min = i.target.x.min, a.x.max = a.x.min + h;
+          const f = E(this.layout.layoutBox.y);
+          a.y.min = i.target.y.min, a.y.max = a.y.min + f;
+        }
+        j(r, a), ot(r, u), mt(this.projectionDeltaWithTransform, this.layoutCorrected, r, u);
+      }
+    }
+    registerSharedNode(i, r) {
+      this.sharedNodes.has(i) || this.sharedNodes.set(i, new sr()), this.sharedNodes.get(i).add(r);
+      const l = r.options.initialPromotionConfig;
+      r.promote({
+        transition: l ? l.transition : void 0,
+        preserveFollowOpacity: l && l.shouldPreserveFollowOpacity ? l.shouldPreserveFollowOpacity(r) : void 0
+      });
+    }
+    isLead() {
+      const i = this.getStack();
+      return i ? i.lead === this : !0;
+    }
+    getLead() {
+      var i;
+      const { layoutId: r } = this.options;
+      return r ? ((i = this.getStack()) === null || i === void 0 ? void 0 : i.lead) || this : this;
+    }
+    getPrevLead() {
+      var i;
+      const { layoutId: r } = this.options;
+      return r ? (i = this.getStack()) === null || i === void 0 ? void 0 : i.prevLead : void 0;
+    }
+    getStack() {
+      const { layoutId: i } = this.options;
+      if (i)
+        return this.root.sharedNodes.get(i);
+    }
+    promote({ needsReset: i, transition: r, preserveFollowOpacity: a } = {}) {
+      const l = this.getStack();
+      l && l.promote(this, a), i && (this.projectionDelta = void 0, this.needsReset = !0), r && this.setOptions({ transition: r });
+    }
+    relegate() {
+      const i = this.getStack();
+      return i ? i.relegate(this) : !1;
+    }
+    resetRotation() {
+      const { visualElement: i } = this.options;
+      if (!i)
+        return;
+      let r = !1;
+      const { latestValues: a } = i;
+      if ((a.rotate || a.rotateX || a.rotateY || a.rotateZ) && (r = !0), !r)
+        return;
+      const l = {};
+      for (let u = 0; u < en.length; u++) {
+        const h = "rotate" + en[u];
+        a[h] && (l[h] = a[h], i.setStaticValue(h, 0));
+      }
+      i.render();
+      for (const u in l)
+        i.setStaticValue(u, l[u]);
+      i.scheduleRender();
+    }
+    getProjectionStyles(i = {}) {
+      var r, a;
+      const l = {};
+      if (!this.instance || this.isSVG)
+        return l;
+      if (this.isVisible)
+        l.visibility = "";
+      else
+        return { visibility: "hidden" };
+      const u = this.getTransformTemplate();
+      if (this.needsReset)
+        return this.needsReset = !1, l.opacity = "", l.pointerEvents = jt(i.pointerEvents) || "", l.transform = u ? u(this.latestValues, "") : "none", l;
+      const h = this.getLead();
+      if (!this.projectionDelta || !this.layout || !h.target) {
+        const m = {};
+        return this.options.layoutId && (m.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1, m.pointerEvents = jt(i.pointerEvents) || ""), this.hasProjected && !J(this.latestValues) && (m.transform = u ? u({}, "") : "none", this.hasProjected = !1), m;
+      }
+      const f = h.animationValues || h.latestValues;
+      this.applyTransformsToTarget(), l.transform = tn(this.projectionDeltaWithTransform, this.treeScale, f), u && (l.transform = u(f, l.transform));
+      const { x: d, y: p } = this.projectionDelta;
+      l.transformOrigin = `${d.origin * 100}% ${p.origin * 100}% 0`, h.animationValues ? l.opacity = h === this ? (a = (r = f.opacity) !== null && r !== void 0 ? r : this.latestValues.opacity) !== null && a !== void 0 ? a : 1 : this.preserveOpacity ? this.latestValues.opacity : f.opacityExit : l.opacity = h === this ? f.opacity !== void 0 ? f.opacity : "" : f.opacityExit !== void 0 ? f.opacityExit : 0;
+      for (const m in ye) {
+        if (f[m] === void 0)
+          continue;
+        const { correct: v, applyTo: V } = ye[m], y = l.transform === "none" ? f[m] : v(f[m], h);
+        if (V) {
+          const g = V.length;
+          for (let P = 0; P < g; P++)
+            l[V[P]] = y;
+        } else
+          l[m] = y;
+      }
+      return this.options.layoutId && (l.pointerEvents = h === this ? jt(i.pointerEvents) || "" : "none"), l;
+    }
+    clearSnapshot() {
+      this.resumeFrom = this.snapshot = void 0;
+    }
+    // Only run on root
+    resetTree() {
+      this.root.nodes.forEach((i) => {
+        var r;
+        return (r = i.currentAnimation) === null || r === void 0 ? void 0 : r.stop();
+      }), this.root.nodes.forEach(sn), this.root.sharedNodes.clear();
+    }
+  };
+}
+function hr(e) {
+  e.updateLayout();
+}
+function fr(e) {
+  var t;
+  const n = ((t = e.resumeFrom) === null || t === void 0 ? void 0 : t.snapshot) || e.snapshot;
+  if (e.isLead() && e.layout && n && e.hasListeners("didUpdate")) {
+    const { layoutBox: s, measuredBox: o } = e.layout, { animationType: c } = e.options, i = n.source !== e.layout.source;
+    c === "size" ? I((h) => {
+      const f = i ? n.measuredBox[h] : n.layoutBox[h], d = E(f);
+      f.min = s[h].min, f.max = f.min + d;
+    }) : ds(c, n.layoutBox, s) && I((h) => {
+      const f = i ? n.measuredBox[h] : n.layoutBox[h], d = E(s[h]);
+      f.max = f.min + d, e.relativeTarget && !e.currentAnimation && (e.isProjectionDirty = !0, e.relativeTarget[h].max = e.relativeTarget[h].min + d);
+    });
+    const r = it();
+    mt(r, s, n.layoutBox);
+    const a = it();
+    i ? mt(a, e.applyTransform(o, !0), n.measuredBox) : mt(a, s, n.layoutBox);
+    const l = !us(r);
+    let u = !1;
+    if (!e.resumeFrom) {
+      const h = e.getClosestProjectingParent();
+      if (h && !h.resumeFrom) {
+        const { snapshot: f, layout: d } = h;
+        if (f && d) {
+          const p = D();
+          gt(p, n.layoutBox, f.layoutBox);
+          const m = D();
+          gt(m, s, d.layoutBox), hs(p, m) || (u = !0), h.options.layoutRoot && (e.relativeTarget = m, e.relativeTargetOrigin = p, e.relativeParent = h);
+        }
+      }
+    }
+    e.notifyListeners("didUpdate", {
+      layout: s,
+      snapshot: n,
+      delta: a,
+      layoutDelta: r,
+      hasLayoutChanged: l,
+      hasRelativeTargetChanged: u
+    });
+  } else if (e.isLead()) {
+    const { onExitComplete: s } = e.options;
+    s && s();
+  }
+  e.options.transition = void 0;
+}
+function dr(e) {
+  Q.totalNodes++, e.parent && (e.isProjecting() || (e.isProjectionDirty = e.parent.isProjectionDirty), e.isSharedProjectionDirty || (e.isSharedProjectionDirty = !!(e.isProjectionDirty || e.parent.isProjectionDirty || e.parent.isSharedProjectionDirty)), e.isTransformDirty || (e.isTransformDirty = e.parent.isTransformDirty));
+}
+function pr(e) {
+  e.isProjectionDirty = e.isSharedProjectionDirty = e.isTransformDirty = !1;
+}
+function mr(e) {
+  e.clearSnapshot();
+}
+function sn(e) {
+  e.clearMeasurements();
+}
+function gr(e) {
+  e.isLayoutDirty = !1;
+}
+function yr(e) {
+  const { visualElement: t } = e.options;
+  t && t.getProps().onBeforeLayoutMeasure && t.notify("BeforeLayoutMeasure"), e.resetTransform();
+}
+function on(e) {
+  e.finishAnimation(), e.targetDelta = e.relativeTarget = e.target = void 0, e.isProjectionDirty = !0;
+}
+function vr(e) {
+  e.resolveTargetDelta();
+}
+function Pr(e) {
+  e.calcProjection();
+}
+function xr(e) {
+  e.resetRotation();
+}
+function Tr(e) {
+  e.removeLeadSnapshot();
+}
+function rn(e, t, n) {
+  e.translate = w(t.translate, 0, n), e.scale = w(t.scale, 1, n), e.origin = t.origin, e.originPoint = t.originPoint;
+}
+function an(e, t, n, s) {
+  e.min = w(t.min, n.min, s), e.max = w(t.max, n.max, s);
+}
+function Vr(e, t, n, s) {
+  an(e.x, t.x, n.x, s), an(e.y, t.y, n.y, s);
+}
+function Sr(e) {
+  return e.animationValues && e.animationValues.opacityExit !== void 0;
+}
+const br = {
+  duration: 0.45,
+  ease: [0.4, 0, 0.1, 1]
+}, ln = (e) => typeof navigator < "u" && navigator.userAgent.toLowerCase().includes(e), cn = ln("applewebkit/") && !ln("chrome/") ? Math.round : B;
+function un(e) {
+  e.min = cn(e.min), e.max = cn(e.max);
+}
+function Ar(e) {
+  un(e.x), un(e.y);
+}
+function ds(e, t, n) {
+  return e === "position" || e === "preserve-aspect" && !Jt(Qe(t), Qe(n), 0.2);
+}
+const Dr = fs({
+  attachResizeListener: (e, t) => N(e, "resize", t),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body.scrollLeft,
+    y: document.documentElement.scrollTop || document.body.scrollTop
+  }),
+  checkIsScrollRoot: () => !0
+}), Kt = {
+  current: void 0
+}, ps = fs({
+  measureScroll: (e) => ({
+    x: e.scrollLeft,
+    y: e.scrollTop
+  }),
+  defaultParent: () => {
+    if (!Kt.current) {
+      const e = new Dr({});
+      e.mount(window), e.setOptions({ layoutScroll: !0 }), Kt.current = e;
+    }
+    return Kt.current;
+  },
+  resetTransform: (e, t) => {
+    e.style.transform = t !== void 0 ? t : "none";
+  },
+  checkIsScrollRoot: (e) => window.getComputedStyle(e).position === "fixed"
+}), Cr = {
+  pan: {
+    Feature: zo
+  },
+  drag: {
+    Feature: $o,
+    ProjectionNode: ps,
+    MeasureLayout: as
+  }
+}, Mr = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;
+function wr(e) {
+  const t = Mr.exec(e);
+  if (!t)
+    return [,];
+  const [, n, s] = t;
+  return [n, s];
+}
+const Lr = 4;
+function ne(e, t, n = 1) {
+  tt(n <= Lr, `Max CSS variable fallback depth detected in property "${e}". This may indicate a circular fallback dependency.`);
+  const [s, o] = wr(e);
+  if (!s)
+    return;
+  const c = window.getComputedStyle(t).getPropertyValue(s);
+  if (c) {
+    const i = c.trim();
+    return Zn(i) ? parseFloat(i) : i;
+  } else
+    return Ht(o) ? ne(o, t, n + 1) : o;
+}
+function Rr(e, { ...t }, n) {
+  const s = e.current;
+  if (!(s instanceof Element))
+    return { target: t, transitionEnd: n };
+  n && (n = { ...n }), e.values.forEach((o) => {
+    const c = o.get();
+    if (!Ht(c))
+      return;
+    const i = ne(c, s);
+    i && o.set(i);
+  });
+  for (const o in t) {
+    const c = t[o];
+    if (!Ht(c))
+      continue;
+    const i = ne(c, s);
+    i && (t[o] = i, n || (n = {}), n[o] === void 0 && (n[o] = c));
+  }
+  return { target: t, transitionEnd: n };
+}
+const Br = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "x",
+  "y",
+  "translateX",
+  "translateY"
+]), ms = (e) => Br.has(e), Fr = (e) => Object.keys(e).some(ms), At = (e) => e === vn || e === xt, hn = (e, t) => parseFloat(e.split(", ")[t]), fn = (e, t) => (n, { transform: s }) => {
+  if (s === "none" || !s)
+    return 0;
+  const o = s.match(/^matrix3d\((.+)\)$/);
+  if (o)
+    return hn(o[1], t);
+  {
+    const c = s.match(/^matrix\((.+)\)$/);
+    return c ? hn(c[1], e) : 0;
+  }
+}, Er = /* @__PURE__ */ new Set(["x", "y", "z"]), jr = Fs.filter((e) => !Er.has(e));
+function kr(e) {
+  const t = [];
+  return jr.forEach((n) => {
+    const s = e.getValue(n);
+    s !== void 0 && (t.push([n, s.get()]), s.set(n.startsWith("scale") ? 1 : 0));
+  }), t.length && e.render(), t;
+}
+const lt = {
+  // Dimensions
+  width: ({ x: e }, { paddingLeft: t = "0", paddingRight: n = "0" }) => e.max - e.min - parseFloat(t) - parseFloat(n),
+  height: ({ y: e }, { paddingTop: t = "0", paddingBottom: n = "0" }) => e.max - e.min - parseFloat(t) - parseFloat(n),
+  top: (e, { top: t }) => parseFloat(t),
+  left: (e, { left: t }) => parseFloat(t),
+  bottom: ({ y: e }, { top: t }) => parseFloat(t) + (e.max - e.min),
+  right: ({ x: e }, { left: t }) => parseFloat(t) + (e.max - e.min),
+  // Transform
+  x: fn(4, 13),
+  y: fn(5, 14)
+};
+lt.translateX = lt.x;
+lt.translateY = lt.y;
+const Ir = (e, t, n) => {
+  const s = t.measureViewportBox(), o = t.current, c = getComputedStyle(o), { display: i } = c, r = {};
+  i === "none" && t.setStaticValue("display", e.display || "block"), n.forEach((l) => {
+    r[l] = lt[l](s, c);
+  }), t.render();
+  const a = t.measureViewportBox();
+  return n.forEach((l) => {
+    const u = t.getValue(l);
+    u && u.jump(r[l]), e[l] = lt[l](a, c);
+  }), e;
+}, Or = (e, t, n = {}, s = {}) => {
+  t = { ...t }, s = { ...s };
+  const o = Object.keys(t).filter(ms);
+  let c = [], i = !1;
+  const r = [];
+  if (o.forEach((a) => {
+    const l = e.getValue(a);
+    if (!e.hasValue(a))
+      return;
+    let u = n[a], h = ht(u);
+    const f = t[a];
+    let d;
+    if ($t(f)) {
+      const p = f.length, m = f[0] === null ? 1 : 0;
+      u = f[m], h = ht(u);
+      for (let v = m; v < p && f[v] !== null; v++)
+        d ? tt(ht(f[v]) === d, "All keyframes must be of the same type") : (d = ht(f[v]), tt(d === h || At(h) && At(d), "Keyframes must be of the same dimension as the current value"));
+    } else
+      d = ht(f);
+    if (h !== d)
+      if (At(h) && At(d)) {
+        const p = l.get();
+        typeof p == "string" && l.set(parseFloat(p)), typeof f == "string" ? t[a] = parseFloat(f) : Array.isArray(f) && d === xt && (t[a] = f.map(parseFloat));
+      } else
+        h != null && h.transform && (d != null && d.transform) && (u === 0 || f === 0) ? u === 0 ? l.set(d.transform(u)) : t[a] = h.transform(f) : (i || (c = kr(e), i = !0), r.push(a), s[a] = s[a] !== void 0 ? s[a] : t[a], l.jump(f));
+  }), r.length) {
+    const a = r.indexOf("height") >= 0 ? window.pageYOffset : null, l = Ir(t, e, r);
+    return c.length && c.forEach(([u, h]) => {
+      e.getValue(u).set(h);
+    }), e.render(), An && a !== null && window.scrollTo({ top: a }), { target: l, transitionEnd: s };
+  } else
+    return { target: t, transitionEnd: s };
+};
+function Ur(e, t, n, s) {
+  return Fr(t) ? Or(e, t, n, s) : { target: t, transitionEnd: s };
+}
+const Nr = (e, t, n, s) => {
+  const o = Rr(e, t, s);
+  return t = o.target, s = o.transitionEnd, Ur(e, t, n, s);
+}, se = { current: null }, gs = { current: !1 };
+function Gr() {
+  if (gs.current = !0, !!An)
+    if (window.matchMedia) {
+      const e = window.matchMedia("(prefers-reduced-motion)"), t = () => se.current = e.matches;
+      e.addListener(t), t();
+    } else
+      se.current = !1;
+}
+function Kr(e, t, n) {
+  const { willChange: s } = t;
+  for (const o in t) {
+    const c = t[o], i = n[o];
+    if (nt(c))
+      e.addValue(o, c), wt(s) && s.add(o), process.env.NODE_ENV === "development" && Dn(c.version === "10.16.4", `Attempting to mix Framer Motion versions ${c.version} with 10.16.4 may not work as expected.`);
+    else if (nt(i))
+      e.addValue(o, at(c, { owner: e })), wt(s) && s.remove(o);
+    else if (i !== c)
+      if (e.hasValue(o)) {
+        const r = e.getValue(o);
+        !r.hasAnimated && r.set(c);
+      } else {
+        const r = e.getStaticValue(o);
+        e.addValue(o, at(r !== void 0 ? r : c, { owner: e }));
+      }
+  }
+  for (const o in n)
+    t[o] === void 0 && e.removeValue(o);
+  return t;
+}
+const dn = /* @__PURE__ */ new WeakMap(), ys = Object.keys(Cn), $r = ys.length, pn = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+], zr = Mn.length;
+class Hr {
+  constructor({ parent: t, props: n, presenceContext: s, reducedMotionConfig: o, visualState: c }, i = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.scheduleRender = () => C.render(this.render, !1, !0);
+    const { latestValues: r, renderState: a } = c;
+    this.latestValues = r, this.baseTarget = { ...r }, this.initialValues = n.initial ? { ...r } : {}, this.renderState = a, this.parent = t, this.props = n, this.presenceContext = s, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = o, this.options = i, this.isControllingVariants = Es(n), this.isVariantNode = js(n), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: l, ...u } = this.scrapeMotionValuesFromProps(n, {});
+    for (const h in u) {
+      const f = u[h];
+      r[h] !== void 0 && nt(f) && (f.set(r[h], !1), wt(l) && l.add(h));
+    }
+  }
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(t, n) {
+    return {};
+  }
+  mount(t) {
+    this.current = t, dn.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((n, s) => this.bindToMotionValue(s, n)), gs.current || Gr(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : se.current, process.env.NODE_ENV !== "production" && Dn(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), this.parent && this.parent.children.add(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    dn.delete(this.current), this.projection && this.projection.unmount(), $(this.notifyUpdate), $(this.render), this.valueSubscriptions.forEach((t) => t()), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent && this.parent.children.delete(this);
+    for (const t in this.events)
+      this.events[t].clear();
+    for (const t in this.features)
+      this.features[t].unmount();
+    this.current = null;
+  }
+  bindToMotionValue(t, n) {
+    const s = Pt.has(t), o = n.on("change", (i) => {
+      this.latestValues[t] = i, this.props.onUpdate && C.update(this.notifyUpdate, !1, !0), s && this.projection && (this.projection.isTransformDirty = !0);
+    }), c = n.on("renderRequest", this.scheduleRender);
+    this.valueSubscriptions.set(t, () => {
+      o(), c();
+    });
+  }
+  sortNodePosition(t) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== t.type ? 0 : this.sortInstanceNodePosition(this.current, t.current);
+  }
+  loadFeatures({ children: t, ...n }, s, o, c) {
+    let i, r;
+    if (process.env.NODE_ENV !== "production" && o && s) {
+      const a = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+      n.ignoreStrict ? ie(!1, a) : tt(!1, a);
+    }
+    for (let a = 0; a < $r; a++) {
+      const l = ys[a], { isEnabled: u, Feature: h, ProjectionNode: f, MeasureLayout: d } = Cn[l];
+      f && (i = f), u(n) && (!this.features[l] && h && (this.features[l] = new h(this)), d && (r = d));
+    }
+    if (!this.projection && i) {
+      this.projection = new i(this.latestValues, this.parent && this.parent.projection);
+      const { layoutId: a, layout: l, drag: u, dragConstraints: h, layoutScroll: f, layoutRoot: d } = n;
+      this.projection.setOptions({
+        layoutId: a,
+        layout: l,
+        alwaysMeasureLayout: !!u || h && dt(h),
+        visualElement: this,
+        scheduleRender: () => this.scheduleRender(),
+        /**
+         * 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 l == "string" ? l : "both",
+        initialPromotionConfig: c,
+        layoutScroll: f,
+        layoutRoot: d
+      });
+    }
+    return r;
+  }
+  updateFeatures() {
+    for (const t in this.features) {
+      const n = this.features[t];
+      n.isMounted ? n.update() : (n.mount(), n.isMounted = !0);
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.options, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : D();
+  }
+  getStaticValue(t) {
+    return this.latestValues[t];
+  }
+  setStaticValue(t, n) {
+    this.latestValues[t] = n;
+  }
+  /**
+   * Make a target animatable by Popmotion. For instance, if we're
+   * trying to animate width from 100px to 100vw we need to measure 100vw
+   * in pixels to determine what we really need to animate to. This is also
+   * pluggable to support Framer's custom value types like Color,
+   * and CSS variables.
+   */
+  makeTargetAnimatable(t, n = !0) {
+    return this.makeTargetAnimatableFromInstance(t, this.props, n);
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(t, n) {
+    (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = n;
+    for (let s = 0; s < pn.length; s++) {
+      const o = pn[s];
+      this.propEventSubscriptions[o] && (this.propEventSubscriptions[o](), delete this.propEventSubscriptions[o]);
+      const c = t["on" + o];
+      c && (this.propEventSubscriptions[o] = this.on(o, c));
+    }
+    this.prevMotionValues = Kr(this, this.scrapeMotionValuesFromProps(t, this.prevProps), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(t) {
+    return this.props.variants ? this.props.variants[t] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  getVariantContext(t = !1) {
+    if (t)
+      return this.parent ? this.parent.getVariantContext() : void 0;
+    if (!this.isControllingVariants) {
+      const s = this.parent ? this.parent.getVariantContext() || {} : {};
+      return this.props.initial !== void 0 && (s.initial = this.props.initial), s;
+    }
+    const n = {};
+    for (let s = 0; s < zr; s++) {
+      const o = Mn[s], c = this.props[o];
+      (Tn(c) || c === !1) && (n[o] = c);
+    }
+    return n;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(t) {
+    const n = this.getClosestVariantNode();
+    if (n)
+      return n.variantChildren && n.variantChildren.add(t), () => n.variantChildren.delete(t);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(t, n) {
+    n !== this.values.get(t) && (this.removeValue(t), this.bindToMotionValue(t, n)), this.values.set(t, n), this.latestValues[t] = n.get();
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(t) {
+    this.values.delete(t);
+    const n = this.valueSubscriptions.get(t);
+    n && (n(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(t) {
+    return this.values.has(t);
+  }
+  getValue(t, n) {
+    if (this.props.values && this.props.values[t])
+      return this.props.values[t];
+    let s = this.values.get(t);
+    return s === void 0 && n !== void 0 && (s = at(n, { owner: this }), this.addValue(t, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(t) {
+    var n;
+    return this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : (n = this.getBaseTargetFromProps(this.props, t)) !== null && n !== void 0 ? n : this.readValueFromInstance(this.current, t, this.options);
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(t, n) {
+    this.baseTarget[t] = n;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(t) {
+    var n;
+    const { initial: s } = this.props, o = typeof s == "string" || typeof s == "object" ? (n = mn(this.props, s)) === null || n === void 0 ? void 0 : n[t] : void 0;
+    if (s && o !== void 0)
+      return o;
+    const c = this.getBaseTargetFromProps(this.props, t);
+    return c !== void 0 && !nt(c) ? c : this.initialValues[t] !== void 0 && o === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, n) {
+    return this.events[t] || (this.events[t] = new bn()), this.events[t].add(n);
+  }
+  notify(t, ...n) {
+    this.events[t] && this.events[t].notify(...n);
+  }
+}
+class vs extends Hr {
+  sortInstanceNodePosition(t, n) {
+    return t.compareDocumentPosition(n) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(t, n) {
+    return t.style ? t.style[n] : void 0;
+  }
+  removeValueFromRenderState(t, { vars: n, style: s }) {
+    delete n[t], delete s[t];
+  }
+  makeTargetAnimatableFromInstance({ transition: t, transitionEnd: n, ...s }, { transformValues: o }, c) {
+    let i = lo(s, t || {}, this);
+    if (o && (n && (n = o(n)), s && (s = o(s)), i && (i = o(i))), c) {
+      ro(this, s, i);
+      const r = Nr(this, s, i, n);
+      n = r.transitionEnd, s = r.target;
+    }
+    return {
+      transition: t,
+      transitionEnd: n,
+      ...s
+    };
+  }
+}
+function _r(e) {
+  return window.getComputedStyle(e);
+}
+class Wr extends vs {
+  readValueFromInstance(t, n) {
+    if (Pt.has(n)) {
+      const s = ae(n);
+      return s && s.default || 0;
+    } else {
+      const s = _r(t), o = (ks(n) ? s.getPropertyValue(n) : s[n]) || 0;
+      return typeof o == "string" ? o.trim() : o;
+    }
+  }
+  measureInstanceViewportBox(t, { transformPagePoint: n }) {
+    return rs(t, n);
+  }
+  build(t, n, s, o) {
+    Is(t, n, s, o.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(t, n) {
+    return Os(t, n);
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: t } = this.props;
+    nt(t) && (this.childSubscription = t.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+  renderInstance(t, n, s, o) {
+    Us(t, n, s, o);
+  }
+}
+class Yr extends vs {
+  constructor() {
+    super(...arguments), this.isSVGTag = !1;
+  }
+  getBaseTargetFromProps(t, n) {
+    return t[n];
+  }
+  readValueFromInstance(t, n) {
+    if (Pt.has(n)) {
+      const s = ae(n);
+      return s && s.default || 0;
+    }
+    return n = Ns.has(n) ? n : gn(n), t.getAttribute(n);
+  }
+  measureInstanceViewportBox() {
+    return D();
+  }
+  scrapeMotionValuesFromProps(t, n) {
+    return Gs(t, n);
+  }
+  build(t, n, s, o) {
+    Ks(t, n, s, this.isSVGTag, o.transformTemplate);
+  }
+  renderInstance(t, n, s, o) {
+    $s(t, n, s, o);
+  }
+  mount(t) {
+    this.isSVGTag = zs(t.tagName), super.mount(t);
+  }
+}
+const qr = (e, t) => Hs(e) ? new Yr(t, { enableHardwareAcceleration: !1 }) : new Wr(t, { enableHardwareAcceleration: !0 }), Xr = {
+  layout: {
+    ProjectionNode: ps,
+    MeasureLayout: as
+  }
+}, Zr = {
+  renderer: qr,
+  ...So,
+  ...oi
+}, ca = {
+  ...Zr,
+  ...Cr,
+  ...Xr
+};
+export {
+  ca as default
+};