@zydon/common 1.1.62 → 1.1.64

package/dist/features-71eac2d4.js

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