@konstructio/ui 0.1.2-alpha.10 → 0.1.2-alpha.101

package/dist/react-CvUtBTMg.js

@@ -0,0 +1,4683 @@
+import { a as Nr, n as Ur, r as Wr } from "./rolldown-runtime-Ck3dxwZt.js";
+import { Component as $r, Fragment as qn, createContext as Vt, createElement as Kr, forwardRef as _r, useCallback as Zn, useContext as U, useEffect as ni, useId as zr, useInsertionEffect as Jn, useLayoutEffect as Hr, useMemo as he, useRef as ft } from "react";
+import { jsx as Qn, jsxs as Gr } from "react/jsx-runtime";
+var ts = Vt({});
+function Xr(t) {
+  const e = ft(null);
+  return e.current === null && (e.current = t()), e.current;
+}
+var Yr = typeof window < "u", qr = Yr ? Hr : ni, si = /* @__PURE__ */ Vt(null);
+function ri(t, e) {
+  t.indexOf(e) === -1 && t.push(e);
+}
+function ie(t, e) {
+  const i = t.indexOf(e);
+  i > -1 && t.splice(i, 1);
+}
+var Q = (t, e, i) => i > e ? e : i < t ? t : i;
+function Re(t, e) {
+  return e ? `${t}. For more information and steps for solving, visit https://motion.dev/troubleshooting/${e}` : t;
+}
+var Mt = () => {
+}, it = () => {
+};
+typeof process < "u" && process.env.NODE_ENV !== "production" && (Mt = (t, e, i) => {
+  !t && typeof console < "u" && console.warn(Re(e, i));
+}, it = (t, e, i) => {
+  if (!t) throw new Error(Re(e, i));
+});
+var st = {}, es = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t), is = (t) => typeof t == "object" && t !== null, ns = (t) => /^0[^.\s]+$/u.test(t);
+// @__NO_SIDE_EFFECTS__
+function ss(t) {
+  let e;
+  return () => (e === void 0 && (e = t()), e);
+}
+var _ = /* @__NO_SIDE_EFFECTS__ */ (t) => t, Ut = (...t) => t.reduce((e, i) => (n) => i(e(n))), Ft = /* @__NO_SIDE_EFFECTS__ */ (t, e, i) => {
+  const n = e - t;
+  return n ? (i - t) / n : 1;
+}, oi = class {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(t) {
+    return ri(this.subscriptions, t), () => ie(this.subscriptions, t);
+  }
+  notify(t, e, i) {
+    const n = this.subscriptions.length;
+    if (n)
+      if (n === 1) this.subscriptions[0](t, e, i);
+      else for (let s = 0; s < n; s++) {
+        const o = this.subscriptions[s];
+        o && o(t, e, i);
+      }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}, W = /* @__NO_SIDE_EFFECTS__ */ (t) => t * 1e3, K = /* @__NO_SIDE_EFFECTS__ */ (t) => t / 1e3, rs = /* @__NO_SIDE_EFFECTS__ */ (t, e) => e ? t * (1e3 / e) : 0, Ri = /* @__PURE__ */ new Set();
+function ai(t, e, i) {
+  t || Ri.has(e) || (console.warn(Re(e, i)), Ri.add(e));
+}
+var os = (t, e, i) => (((1 - 3 * i + 3 * e) * t + (3 * i - 6 * e)) * t + 3 * e) * t, Zr = 1e-7, Jr = 12;
+function Qr(t, e, i, n, s) {
+  let o, r, a = 0;
+  do
+    r = e + (i - e) / 2, o = os(r, n, s) - t, o > 0 ? i = r : e = r;
+  while (Math.abs(o) > Zr && ++a < Jr);
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function Wt(t, e, i, n) {
+  if (t === e && i === n) return _;
+  const s = (o) => Qr(o, 0, 1, t, i);
+  return (o) => o === 0 || o === 1 ? o : os(s(o), e, n);
+}
+var as = /* @__NO_SIDE_EFFECTS__ */ (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, ls = /* @__NO_SIDE_EFFECTS__ */ (t) => (e) => 1 - t(1 - e), us = /* @__PURE__ */ Wt(0.33, 1.53, 0.69, 0.99), li = /* @__PURE__ */ ls(us), cs = /* @__PURE__ */ as(li), hs = (t) => t >= 1 ? 1 : (t *= 2) < 1 ? 0.5 * li(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), ui = (t) => 1 - Math.sin(Math.acos(t)), fs = ls(ui), ds = as(ui), to = /* @__PURE__ */ Wt(0.42, 0, 1, 1), eo = /* @__PURE__ */ Wt(0, 0, 0.58, 1), ps = /* @__PURE__ */ Wt(0.42, 0, 0.58, 1), io = /* @__NO_SIDE_EFFECTS__ */ (t) => Array.isArray(t) && typeof t[0] != "number", ms = /* @__NO_SIDE_EFFECTS__ */ (t) => Array.isArray(t) && typeof t[0] == "number", Li = {
+  linear: _,
+  easeIn: to,
+  easeInOut: ps,
+  easeOut: eo,
+  circIn: ui,
+  circInOut: ds,
+  circOut: fs,
+  backIn: li,
+  backInOut: cs,
+  backOut: us,
+  anticipate: hs
+}, no = (t) => typeof t == "string", ki = (t) => {
+  if (ms(t)) {
+    it(t.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+    const [e, i, n, s] = t;
+    return /* @__PURE__ */ Wt(e, i, n, s);
+  } else if (no(t))
+    return it(Li[t] !== void 0, `Invalid easing type '${t}'`, "invalid-easing-type"), Li[t];
+  return t;
+}, _t = [
+  "setup",
+  "read",
+  "resolveKeyframes",
+  "preUpdate",
+  "update",
+  "preRender",
+  "render",
+  "postRender"
+];
+function so(t) {
+  let e = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), n = !1, s = !1;
+  const o = /* @__PURE__ */ new WeakSet();
+  let r = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  };
+  function a(c) {
+    o.has(c) && (l.schedule(c), t()), c(r);
+  }
+  const l = {
+    schedule: (c, u = !1, h = !1) => {
+      const f = h && n ? e : i;
+      return u && o.add(c), f.add(c), c;
+    },
+    cancel: (c) => {
+      i.delete(c), o.delete(c);
+    },
+    process: (c) => {
+      if (r = c, n) {
+        s = !0;
+        return;
+      }
+      n = !0;
+      const u = e;
+      e = i, i = u, e.forEach(a), e.clear(), n = !1, s && (s = !1, l.process(c));
+    }
+  };
+  return l;
+}
+var ro = 40;
+function vs(t, e) {
+  let i = !1, n = !0;
+  const s = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, o = () => i = !0, r = _t.reduce((x, w) => (x[w] = so(o), x), {}), { setup: a, read: l, resolveKeyframes: c, preUpdate: u, update: h, preRender: f, render: p, postRender: d } = r, m = () => {
+    const x = st.useManualTiming, w = x ? s.timestamp : performance.now();
+    i = !1, x || (s.delta = n ? 1e3 / 60 : Math.max(Math.min(w - s.timestamp, ro), 1)), s.timestamp = w, s.isProcessing = !0, a.process(s), l.process(s), c.process(s), u.process(s), h.process(s), f.process(s), p.process(s), d.process(s), s.isProcessing = !1, i && e && (n = !1, t(m));
+  }, v = () => {
+    i = !0, n = !0, s.isProcessing || t(m);
+  };
+  return {
+    schedule: _t.reduce((x, w) => {
+      const P = r[w];
+      return x[w] = (A, D = !1, S = !1) => (i || v(), P.schedule(A, D, S)), x;
+    }, {}),
+    cancel: (x) => {
+      for (let w = 0; w < _t.length; w++) r[_t[w]].cancel(x);
+    },
+    state: s,
+    steps: r
+  };
+}
+var { schedule: M, cancel: rt, state: I, steps: ve } = /* @__PURE__ */ vs(typeof requestAnimationFrame < "u" ? requestAnimationFrame : _, !0), Xt;
+function oo() {
+  Xt = void 0;
+}
+var O = {
+  now: () => (Xt === void 0 && O.set(I.isProcessing || st.useManualTiming ? I.timestamp : performance.now()), Xt),
+  set: (t) => {
+    Xt = t, queueMicrotask(oo);
+  }
+}, gs = (t) => (e) => typeof e == "string" && e.startsWith(t), ys = /* @__PURE__ */ gs("--"), ao = /* @__PURE__ */ gs("var(--"), ci = (t) => ao(t) ? lo.test(t.split("/*")[0].trim()) : !1, lo = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+function Bi(t) {
+  return typeof t != "string" ? !1 : t.split("/*")[0].includes("var(--");
+}
+var Ct = {
+  test: (t) => typeof t == "number",
+  parse: parseFloat,
+  transform: (t) => t
+}, Ot = {
+  ...Ct,
+  transform: (t) => Q(0, 1, t)
+}, zt = {
+  ...Ct,
+  default: 1
+}, kt = (t) => Math.round(t * 1e5) / 1e5, hi = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function uo(t) {
+  return t == null;
+}
+var co = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, fi = (t, e) => (i) => !!(typeof i == "string" && co.test(i) && i.startsWith(t) || e && !uo(i) && Object.prototype.hasOwnProperty.call(i, e)), Ts = (t, e, i) => (n) => {
+  if (typeof n != "string") return n;
+  const [s, o, r, a] = n.match(hi);
+  return {
+    [t]: parseFloat(s),
+    [e]: parseFloat(o),
+    [i]: parseFloat(r),
+    alpha: a !== void 0 ? parseFloat(a) : 1
+  };
+}, ho = (t) => Q(0, 255, t), ge = {
+  ...Ct,
+  transform: (t) => Math.round(ho(t))
+}, dt = {
+  test: /* @__PURE__ */ fi("rgb", "red"),
+  parse: /* @__PURE__ */ Ts("red", "green", "blue"),
+  transform: ({ red: t, green: e, blue: i, alpha: n = 1 }) => "rgba(" + ge.transform(t) + ", " + ge.transform(e) + ", " + ge.transform(i) + ", " + kt(Ot.transform(n)) + ")"
+};
+function fo(t) {
+  let e = "", i = "", n = "", s = "";
+  return t.length > 5 ? (e = t.substring(1, 3), i = t.substring(3, 5), n = t.substring(5, 7), s = t.substring(7, 9)) : (e = t.substring(1, 2), i = t.substring(2, 3), n = t.substring(3, 4), s = t.substring(4, 5), e += e, i += i, n += n, s += s), {
+    red: parseInt(e, 16),
+    green: parseInt(i, 16),
+    blue: parseInt(n, 16),
+    alpha: s ? parseInt(s, 16) / 255 : 1
+  };
+}
+var Le = {
+  test: /* @__PURE__ */ fi("#"),
+  parse: fo,
+  transform: dt.transform
+}, $t = /* @__NO_SIDE_EFFECTS__ */ (t) => ({
+  test: (e) => typeof e == "string" && e.endsWith(t) && e.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (e) => `${e}${t}`
+}), et = /* @__PURE__ */ $t("deg"), J = /* @__PURE__ */ $t("%"), y = /* @__PURE__ */ $t("px"), po = /* @__PURE__ */ $t("vh"), mo = /* @__PURE__ */ $t("vw"), Ii = {
+  ...J,
+  parse: (t) => J.parse(t) / 100,
+  transform: (t) => J.transform(t * 100)
+}, xt = {
+  test: /* @__PURE__ */ fi("hsl", "hue"),
+  parse: /* @__PURE__ */ Ts("hue", "saturation", "lightness"),
+  transform: ({ hue: t, saturation: e, lightness: i, alpha: n = 1 }) => "hsla(" + Math.round(t) + ", " + J.transform(kt(e)) + ", " + J.transform(kt(i)) + ", " + kt(Ot.transform(n)) + ")"
+}, R = {
+  test: (t) => dt.test(t) || Le.test(t) || xt.test(t),
+  parse: (t) => dt.test(t) ? dt.parse(t) : xt.test(t) ? xt.parse(t) : Le.parse(t),
+  transform: (t) => typeof t == "string" ? t : t.hasOwnProperty("red") ? dt.transform(t) : xt.transform(t),
+  getAnimatableNone: (t) => {
+    const e = R.parse(t);
+    return e.alpha = 0, R.transform(e);
+  }
+}, vo = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+function go(t) {
+  return isNaN(t) && typeof t == "string" && (t.match(hi)?.length || 0) + (t.match(vo)?.length || 0) > 0;
+}
+var xs = "number", ws = "color", yo = "var", To = "var(", Fi = "${}", xo = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function bt(t) {
+  const e = t.toString(), i = [], n = {
+    color: [],
+    number: [],
+    var: []
+  }, s = [];
+  let o = 0;
+  return {
+    values: i,
+    split: e.replace(xo, (r) => (R.test(r) ? (n.color.push(o), s.push(ws), i.push(R.parse(r))) : r.startsWith(To) ? (n.var.push(o), s.push(yo), i.push(r)) : (n.number.push(o), s.push(xs), i.push(parseFloat(r))), ++o, Fi)).split(Fi),
+    indexes: n,
+    types: s
+  };
+}
+function wo(t) {
+  return bt(t).values;
+}
+function Ps({ split: t, types: e }) {
+  const i = t.length;
+  return (n) => {
+    let s = "";
+    for (let o = 0; o < i; o++)
+      if (s += t[o], n[o] !== void 0) {
+        const r = e[o];
+        r === xs ? s += kt(n[o]) : r === ws ? s += R.transform(n[o]) : s += n[o];
+      }
+    return s;
+  };
+}
+function Po(t) {
+  return Ps(bt(t));
+}
+var So = (t) => typeof t == "number" ? 0 : R.test(t) ? R.getAnimatableNone(t) : t, bo = (t, e) => typeof t == "number" ? e?.trim().endsWith("/") ? t : 0 : So(t);
+function Ao(t) {
+  const e = bt(t);
+  return Ps(e)(e.values.map((i, n) => bo(i, e.split[n])));
+}
+var G = {
+  test: go,
+  parse: wo,
+  createTransformer: Po,
+  getAnimatableNone: Ao
+};
+function ye(t, e, i) {
+  return i < 0 && (i += 1), i > 1 && (i -= 1), i < 1 / 6 ? t + (e - t) * 6 * i : i < 1 / 2 ? e : i < 2 / 3 ? t + (e - t) * (2 / 3 - i) * 6 : t;
+}
+function Vo({ hue: t, saturation: e, lightness: i, alpha: n }) {
+  t /= 360, e /= 100, i /= 100;
+  let s = 0, o = 0, r = 0;
+  if (!e) s = o = r = i;
+  else {
+    const a = i < 0.5 ? i * (1 + e) : i + e - i * e, l = 2 * i - a;
+    s = ye(l, a, t + 1 / 3), o = ye(l, a, t), r = ye(l, a, t - 1 / 3);
+  }
+  return {
+    red: Math.round(s * 255),
+    green: Math.round(o * 255),
+    blue: Math.round(r * 255),
+    alpha: n
+  };
+}
+function ne(t, e) {
+  return (i) => i > 0 ? e : t;
+}
+var V = (t, e, i) => t + (e - t) * i, Te = (t, e, i) => {
+  const n = t * t, s = i * (e * e - n) + n;
+  return s < 0 ? 0 : Math.sqrt(s);
+}, Mo = [
+  Le,
+  dt,
+  xt
+], Co = (t) => Mo.find((e) => e.test(t));
+function Oi(t) {
+  const e = Co(t);
+  if (Mt(!!e, `'${t}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !e) return !1;
+  let i = e.parse(t);
+  return e === xt && (i = Vo(i)), i;
+}
+var ji = (t, e) => {
+  const i = Oi(t), n = Oi(e);
+  if (!i || !n) return ne(t, e);
+  const s = { ...i };
+  return (o) => (s.red = Te(i.red, n.red, o), s.green = Te(i.green, n.green, o), s.blue = Te(i.blue, n.blue, o), s.alpha = V(i.alpha, n.alpha, o), dt.transform(s));
+}, ke = /* @__PURE__ */ new Set(["none", "hidden"]);
+function Do(t, e) {
+  return ke.has(t) ? (i) => i <= 0 ? t : e : (i) => i >= 1 ? e : t;
+}
+function Eo(t, e) {
+  return (i) => V(t, e, i);
+}
+function di(t) {
+  return typeof t == "number" ? Eo : typeof t == "string" ? ci(t) ? ne : R.test(t) ? ji : ko : Array.isArray(t) ? Ss : typeof t == "object" ? R.test(t) ? ji : Ro : ne;
+}
+function Ss(t, e) {
+  const i = [...t], n = i.length, s = t.map((o, r) => di(o)(o, e[r]));
+  return (o) => {
+    for (let r = 0; r < n; r++) i[r] = s[r](o);
+    return i;
+  };
+}
+function Ro(t, e) {
+  const i = {
+    ...t,
+    ...e
+  }, n = {};
+  for (const s in i) t[s] !== void 0 && e[s] !== void 0 && (n[s] = di(t[s])(t[s], e[s]));
+  return (s) => {
+    for (const o in n) i[o] = n[o](s);
+    return i;
+  };
+}
+function Lo(t, e) {
+  const i = [], n = {
+    color: 0,
+    var: 0,
+    number: 0
+  };
+  for (let s = 0; s < e.values.length; s++) {
+    const o = e.types[s], r = t.indexes[o][n[o]];
+    i[s] = t.values[r] ?? 0, n[o]++;
+  }
+  return i;
+}
+var ko = (t, e) => {
+  const i = G.createTransformer(e), n = bt(t), s = bt(e);
+  return n.indexes.var.length === s.indexes.var.length && n.indexes.color.length === s.indexes.color.length && n.indexes.number.length >= s.indexes.number.length ? ke.has(t) && !s.values.length || ke.has(e) && !n.values.length ? Do(t, e) : Ut(Ss(Lo(n, s), s.values), i) : (Mt(!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.`, "complex-values-different"), ne(t, e));
+};
+function bs(t, e, i) {
+  return typeof t == "number" && typeof e == "number" && typeof i == "number" ? V(t, e, i) : di(t)(t, e);
+}
+var Bo = (t) => {
+  const e = ({ timestamp: i }) => t(i);
+  return {
+    start: (i = !0) => M.update(e, i),
+    stop: () => rt(e),
+    now: () => I.isProcessing ? I.timestamp : O.now()
+  };
+}, As = (t, e, i = 10) => {
+  let n = "";
+  const s = Math.max(Math.round(e / i), 2);
+  for (let o = 0; o < s; o++) n += Math.round(t(o / (s - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${n.substring(0, n.length - 2)})`;
+}, Vs = 2e4;
+function pi(t) {
+  let e = 0;
+  const i = 50;
+  let n = t.next(e);
+  for (; !n.done && e < 2e4; )
+    e += i, n = t.next(e);
+  return e >= 2e4 ? 1 / 0 : e;
+}
+function Io(t, e = 100, i) {
+  const n = i({
+    ...t,
+    keyframes: [0, e]
+  }), s = Math.min(pi(n), Vs);
+  return {
+    type: "keyframes",
+    ease: (o) => n.next(s * o).value / e,
+    duration: K(s)
+  };
+}
+var C = {
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 0,
+  duration: 800,
+  bounce: 0.3,
+  visualDuration: 0.3,
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  minDuration: 0.01,
+  maxDuration: 10,
+  minDamping: 0.05,
+  maxDamping: 1
+};
+function Be(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+var Fo = 12;
+function Oo(t, e, i) {
+  let n = i;
+  for (let s = 1; s < Fo; s++) n = n - t(n) / e(n);
+  return n;
+}
+var Ni = 1e-3;
+function jo({ duration: t = C.duration, bounce: e = C.bounce, velocity: i = C.velocity, mass: n = C.mass }) {
+  let s, o;
+  Mt(t <= W(C.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let r = 1 - e;
+  r = Q(C.minDamping, C.maxDamping, r), t = Q(C.minDuration, C.maxDuration, K(t)), r < 1 ? (s = (c) => {
+    const u = c * r, h = u * t, f = u - i, p = Be(c, r), d = Math.exp(-h);
+    return Ni - f / p * d;
+  }, o = (c) => {
+    const u = c * r * t, h = u * i + i, f = Math.pow(r, 2) * Math.pow(c, 2) * t, p = Math.exp(-u), d = Be(Math.pow(c, 2), r);
+    return (-s(c) + Ni > 0 ? -1 : 1) * ((h - f) * p) / d;
+  }) : (s = (c) => -1e-3 + Math.exp(-c * t) * ((c - i) * t + 1), o = (c) => Math.exp(-c * t) * ((i - c) * (t * t)));
+  const a = 5 / t, l = Oo(s, o, a);
+  if (t = W(t), isNaN(l)) return {
+    stiffness: C.stiffness,
+    damping: C.damping,
+    duration: t
+  };
+  {
+    const c = Math.pow(l, 2) * n;
+    return {
+      stiffness: c,
+      damping: r * 2 * Math.sqrt(n * c),
+      duration: t
+    };
+  }
+}
+var No = ["duration", "bounce"], Uo = [
+  "stiffness",
+  "damping",
+  "mass"
+];
+function Ui(t, e) {
+  return e.some((i) => t[i] !== void 0);
+}
+function Wo(t) {
+  let e = {
+    velocity: C.velocity,
+    stiffness: C.stiffness,
+    damping: C.damping,
+    mass: C.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!Ui(t, Uo) && Ui(t, No))
+    if (e.velocity = 0, t.visualDuration) {
+      const i = t.visualDuration, n = 2 * Math.PI / (i * 1.2), s = n * n, o = 2 * Q(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(s);
+      e = {
+        ...e,
+        mass: C.mass,
+        stiffness: s,
+        damping: o
+      };
+    } else {
+      const i = jo({
+        ...t,
+        velocity: 0
+      });
+      e = {
+        ...e,
+        ...i,
+        mass: C.mass
+      }, e.isResolvedFromDuration = !0;
+    }
+  return e;
+}
+function se(t = C.visualDuration, e = C.bounce) {
+  const i = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: e
+  } : t;
+  let { restSpeed: n, restDelta: s } = i;
+  const o = i.keyframes[0], r = i.keyframes[i.keyframes.length - 1], a = {
+    done: !1,
+    value: o
+  }, { stiffness: l, damping: c, mass: u, duration: h, velocity: f, isResolvedFromDuration: p } = Wo({
+    ...i,
+    velocity: -K(i.velocity || 0)
+  }), d = f || 0, m = c / (2 * Math.sqrt(l * u)), v = r - o, g = K(Math.sqrt(l / u)), T = Math.abs(v) < 5;
+  n || (n = T ? C.restSpeed.granular : C.restSpeed.default), s || (s = T ? C.restDelta.granular : C.restDelta.default);
+  let x, w, P, A, D, S;
+  if (m < 1)
+    P = Be(g, m), A = (d + m * g * v) / P, x = (b) => {
+      const k = Math.exp(-m * g * b);
+      return r - k * (A * Math.sin(P * b) + v * Math.cos(P * b));
+    }, D = m * g * A + v * P, S = m * g * v - A * P, w = (b) => Math.exp(-m * g * b) * (D * Math.sin(P * b) + S * Math.cos(P * b));
+  else if (m === 1) {
+    x = (k) => r - Math.exp(-g * k) * (v + (d + g * v) * k);
+    const b = d + g * v;
+    w = (k) => Math.exp(-g * k) * (g * b * k - d);
+  } else {
+    const b = g * Math.sqrt(m * m - 1);
+    x = (X) => {
+      const tt = Math.exp(-m * g * X), Y = Math.min(b * X, 300);
+      return r - tt * ((d + m * g * v) * Math.sinh(Y) + b * v * Math.cosh(Y)) / b;
+    };
+    const k = (d + m * g * v) / b, N = m * g * k - v * b, at = m * g * v - k * b;
+    w = (X) => {
+      const tt = Math.exp(-m * g * X), Y = Math.min(b * X, 300);
+      return tt * (N * Math.sinh(Y) + at * Math.cosh(Y));
+    };
+  }
+  const E = {
+    calculatedDuration: p && h || null,
+    velocity: (b) => W(w(b)),
+    next: (b) => {
+      if (!p && m < 1) {
+        const N = Math.exp(-m * g * b), at = Math.sin(P * b), X = Math.cos(P * b), tt = r - N * (A * at + v * X), Y = W(N * (D * at + S * X));
+        return a.done = Math.abs(Y) <= n && Math.abs(r - tt) <= s, a.value = a.done ? r : tt, a;
+      }
+      const k = x(b);
+      if (p)
+        a.done = b >= h;
+      else {
+        const N = W(w(b));
+        a.done = Math.abs(N) <= n && Math.abs(r - k) <= s;
+      }
+      return a.value = a.done ? r : k, a;
+    },
+    toString: () => {
+      const b = Math.min(pi(E), Vs), k = As((N) => E.next(b * N).value, b, 30);
+      return b + "ms " + k;
+    },
+    toTransition: () => {
+    }
+  };
+  return E;
+}
+se.applyToOptions = (t) => {
+  const e = Io(t, 100, se);
+  return t.ease = e.ease, t.duration = W(e.duration), t.type = "keyframes", t;
+};
+var $o = 5;
+function Ms(t, e, i) {
+  const n = Math.max(e - $o, 0);
+  return rs(i - t(n), e - n);
+}
+function Ie({ keyframes: t, velocity: e = 0, power: i = 0.8, timeConstant: n = 325, bounceDamping: s = 10, bounceStiffness: o = 500, modifyTarget: r, min: a, max: l, restDelta: c = 0.5, restSpeed: u }) {
+  const h = t[0], f = {
+    done: !1,
+    value: h
+  }, p = (S) => a !== void 0 && S < a || l !== void 0 && S > l, d = (S) => a === void 0 ? l : l === void 0 || Math.abs(a - S) < Math.abs(l - S) ? a : l;
+  let m = i * e;
+  const v = h + m, g = r === void 0 ? v : r(v);
+  g !== v && (m = g - h);
+  const T = (S) => -m * Math.exp(-S / n), x = (S) => g + T(S), w = (S) => {
+    const E = T(S), b = x(S);
+    f.done = Math.abs(E) <= c, f.value = f.done ? g : b;
+  };
+  let P, A;
+  const D = (S) => {
+    p(f.value) && (P = S, A = se({
+      keyframes: [f.value, d(f.value)],
+      velocity: Ms(x, S, f.value),
+      damping: s,
+      stiffness: o,
+      restDelta: c,
+      restSpeed: u
+    }));
+  };
+  return D(0), {
+    calculatedDuration: null,
+    next: (S) => {
+      let E = !1;
+      return !A && P === void 0 && (E = !0, w(S), D(S)), P !== void 0 && S >= P ? A.next(S - P) : (!E && w(S), f);
+    }
+  };
+}
+function Ko(t, e, i) {
+  const n = [], s = i || st.mix || bs, o = t.length - 1;
+  for (let r = 0; r < o; r++) {
+    let a = s(t[r], t[r + 1]);
+    e && (a = Ut(Array.isArray(e) ? e[r] || _ : e, a)), n.push(a);
+  }
+  return n;
+}
+function _o(t, e, { clamp: i = !0, ease: n, mixer: s } = {}) {
+  const o = t.length;
+  if (it(o === e.length, "Both input and output ranges must be the same length", "range-length"), o === 1) return () => e[0];
+  if (o === 2 && e[0] === e[1]) return () => e[1];
+  const r = t[0] === t[1];
+  t[0] > t[o - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const a = Ko(e, n, s), l = a.length, c = (u) => {
+    if (r && u < t[0]) return e[0];
+    let h = 0;
+    if (l > 1)
+      for (; h < t.length - 2 && !(u < t[h + 1]); h++) ;
+    const f = Ft(t[h], t[h + 1], u);
+    return a[h](f);
+  };
+  return i ? (u) => c(Q(t[0], t[o - 1], u)) : c;
+}
+function zo(t, e) {
+  const i = t[t.length - 1];
+  for (let n = 1; n <= e; n++) {
+    const s = Ft(0, e, n);
+    t.push(V(i, 1, s));
+  }
+}
+function Ho(t) {
+  const e = [0];
+  return zo(e, t.length - 1), e;
+}
+function Go(t, e) {
+  return t.map((i) => i * e);
+}
+function Xo(t, e) {
+  return t.map(() => e || ps).splice(0, t.length - 1);
+}
+function wt({ duration: t = 300, keyframes: e, times: i, ease: n = "easeInOut" }) {
+  const s = io(n) ? n.map(ki) : ki(n), o = {
+    done: !1,
+    value: e[0]
+  }, r = _o(Go(i && i.length === e.length ? i : Ho(e), t), e, { ease: Array.isArray(s) ? s : Xo(e, s) });
+  return {
+    calculatedDuration: t,
+    next: (a) => (o.value = r(a), o.done = a >= t, o)
+  };
+}
+var Yo = (t) => t !== null;
+function fe(t, { repeat: e, repeatType: i = "loop" }, n, s = 1) {
+  const o = t.filter(Yo), r = s < 0 || e && i !== "loop" && e % 2 === 1 ? 0 : o.length - 1;
+  return !r || n === void 0 ? o[r] : n;
+}
+var qo = {
+  decay: Ie,
+  inertia: Ie,
+  tween: wt,
+  keyframes: wt,
+  spring: se
+};
+function Cs(t) {
+  typeof t.type == "string" && (t.type = qo[t.type]);
+}
+var mi = class {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((t) => {
+      this.resolve = t;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  then(t, e) {
+    return this.finished.then(t, e);
+  }
+}, Zo = (t) => t / 100, re = class extends mi {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+      done: !1,
+      value: void 0
+    }, this.stop = () => {
+      const { motionValue: e } = this.options;
+      e && e.updatedAt !== O.now() && this.tick(O.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: t } = this;
+    Cs(t);
+    const { type: e = wt, repeat: i = 0, repeatDelay: n = 0, repeatType: s, velocity: o = 0 } = t;
+    let { keyframes: r } = t;
+    const a = e || wt;
+    process.env.NODE_ENV !== "production" && a !== wt && it(r.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${r}`, "spring-two-frames"), a !== wt && typeof r[0] != "number" && (this.mixKeyframes = Ut(Zo, bs(r[0], r[1])), r = [0, 100]);
+    const l = a({
+      ...t,
+      keyframes: r
+    });
+    s === "mirror" && (this.mirroredGenerator = a({
+      ...t,
+      keyframes: [...r].reverse(),
+      velocity: -o
+    })), l.calculatedDuration === null && (l.calculatedDuration = pi(l));
+    const { calculatedDuration: c } = l;
+    this.calculatedDuration = c, this.resolvedDuration = c + n, this.totalDuration = this.resolvedDuration * (i + 1) - n, this.generator = l;
+  }
+  updateTime(t) {
+    const e = Math.round(t - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = e;
+  }
+  tick(t, e = !1) {
+    const { generator: i, totalDuration: n, mixKeyframes: s, mirroredGenerator: o, resolvedDuration: r, calculatedDuration: a } = this;
+    if (this.startTime === null) return i.next(0);
+    const { delay: l = 0, keyframes: c, repeat: u, repeatType: h, repeatDelay: f, type: p, onUpdate: d, finalKeyframe: m } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - n / this.speed, this.startTime)), e ? this.currentTime = t : this.updateTime(t);
+    const v = this.currentTime - l * (this.playbackSpeed >= 0 ? 1 : -1), g = this.playbackSpeed >= 0 ? v < 0 : v > n;
+    this.currentTime = Math.max(v, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = n);
+    let T = this.currentTime, x = i;
+    if (u) {
+      const D = Math.min(this.currentTime, n) / r;
+      let S = Math.floor(D), E = D % 1;
+      !E && D >= 1 && (E = 1), E === 1 && S--, S = Math.min(S, u + 1), S % 2 && (h === "reverse" ? (E = 1 - E, f && (E -= f / r)) : h === "mirror" && (x = o)), T = Q(0, 1, E) * r;
+    }
+    let w;
+    g ? (this.delayState.value = c[0], w = this.delayState) : w = x.next(T), s && !g && (w.value = s(w.value));
+    let { done: P } = w;
+    !g && a !== null && (P = this.playbackSpeed >= 0 ? this.currentTime >= n : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && P);
+    return A && p !== Ie && (w.value = fe(c, this.options, m, this.speed)), d && d(w.value), A && this.finish(), w;
+  }
+  then(t, e) {
+    return this.finished.then(t, e);
+  }
+  get duration() {
+    return K(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + K(t);
+  }
+  get time() {
+    return K(this.currentTime);
+  }
+  set time(t) {
+    t = W(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = t, this.tick(t));
+  }
+  getGeneratorVelocity() {
+    const t = this.currentTime;
+    if (t <= 0) return this.options.velocity || 0;
+    if (this.generator.velocity) return this.generator.velocity(t);
+    const e = this.generator.next(t).value;
+    return Ms((i) => this.generator.next(i).value, t, e);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const e = this.playbackSpeed !== t;
+    e && this.driver && this.updateTime(O.now()), this.playbackSpeed = t, e && this.driver && (this.time = K(this.currentTime));
+  }
+  play() {
+    if (this.isStopped) return;
+    const { driver: t = Bo, startTime: e } = this.options;
+    this.driver || (this.driver = t((n) => this.tick(n))), this.options.onPlay?.();
+    const i = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = i) : this.holdTime !== null ? this.startTime = i - this.holdTime : this.startTime || (this.startTime = e ?? i), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(O.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+  attachTimeline(t) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), t.observe(this);
+  }
+};
+function Jo(t) {
+  for (let e = 1; e < t.length; e++) t[e] ?? (t[e] = t[e - 1]);
+}
+var pt = (t) => t * 180 / Math.PI, Fe = (t) => {
+  const e = pt(Math.atan2(t[1], t[0]));
+  return Oe(e);
+}, Qo = {
+  x: 4,
+  y: 5,
+  translateX: 4,
+  translateY: 5,
+  scaleX: 0,
+  scaleY: 3,
+  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
+  rotate: Fe,
+  rotateZ: Fe,
+  skewX: (t) => pt(Math.atan(t[1])),
+  skewY: (t) => pt(Math.atan(t[2])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
+}, Oe = (t) => (t = t % 360, t < 0 && (t += 360), t), Wi = Fe, $i = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), Ki = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), ta = {
+  x: 12,
+  y: 13,
+  z: 14,
+  translateX: 12,
+  translateY: 13,
+  translateZ: 14,
+  scaleX: $i,
+  scaleY: Ki,
+  scale: (t) => ($i(t) + Ki(t)) / 2,
+  rotateX: (t) => Oe(pt(Math.atan2(t[6], t[5]))),
+  rotateY: (t) => Oe(pt(Math.atan2(-t[2], t[0]))),
+  rotateZ: Wi,
+  rotate: Wi,
+  skewX: (t) => pt(Math.atan(t[4])),
+  skewY: (t) => pt(Math.atan(t[1])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
+};
+function je(t) {
+  return t.includes("scale") ? 1 : 0;
+}
+function Ne(t, e) {
+  if (!t || t === "none") return je(e);
+  const i = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
+  let n, s;
+  if (i)
+    n = ta, s = i;
+  else {
+    const a = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+    n = Qo, s = a;
+  }
+  if (!s) return je(e);
+  const o = n[e], r = s[1].split(",").map(ia);
+  return typeof o == "function" ? o(r) : r[o];
+}
+var ea = (t, e) => {
+  const { transform: i = "none" } = getComputedStyle(t);
+  return Ne(i, e);
+};
+function ia(t) {
+  return parseFloat(t.trim());
+}
+var Dt = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], Et = /* @__PURE__ */ new Set([...Dt, "pathRotation"]), _i = (t) => t === Ct || t === y, na = /* @__PURE__ */ new Set([
+  "x",
+  "y",
+  "z"
+]), sa = Dt.filter((t) => !na.has(t));
+function ra(t) {
+  const e = [];
+  return sa.forEach((i) => {
+    const n = t.getValue(i);
+    n !== void 0 && (e.push([i, n.get()]), n.set(i.startsWith("scale") ? 1 : 0));
+  }), e;
+}
+var nt = {
+  width: ({ x: t }, { paddingLeft: e = "0", paddingRight: i = "0", boxSizing: n }) => {
+    const s = t.max - t.min;
+    return n === "border-box" ? s : s - parseFloat(e) - parseFloat(i);
+  },
+  height: ({ y: t }, { paddingTop: e = "0", paddingBottom: i = "0", boxSizing: n }) => {
+    const s = t.max - t.min;
+    return n === "border-box" ? s : s - parseFloat(e) - parseFloat(i);
+  },
+  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),
+  x: (t, { transform: e }) => Ne(e, "x"),
+  y: (t, { transform: e }) => Ne(e, "y")
+};
+nt.translateX = nt.x;
+nt.translateY = nt.y;
+var mt = /* @__PURE__ */ new Set(), Ue = !1, We = !1, $e = !1;
+function Ds() {
+  if (We) {
+    const t = Array.from(mt).filter((n) => n.needsMeasurement), e = new Set(t.map((n) => n.element)), i = /* @__PURE__ */ new Map();
+    e.forEach((n) => {
+      const s = ra(n);
+      s.length && (i.set(n, s), n.render());
+    }), t.forEach((n) => n.measureInitialState()), e.forEach((n) => {
+      n.render();
+      const s = i.get(n);
+      s && s.forEach(([o, r]) => {
+        n.getValue(o)?.set(r);
+      });
+    }), t.forEach((n) => n.measureEndState()), t.forEach((n) => {
+      n.suspendedScrollY !== void 0 && window.scrollTo(0, n.suspendedScrollY);
+    });
+  }
+  We = !1, Ue = !1, mt.forEach((t) => t.complete($e)), mt.clear();
+}
+function Es() {
+  mt.forEach((t) => {
+    t.readKeyframes(), t.needsMeasurement && (We = !0);
+  });
+}
+function oa() {
+  $e = !0, Es(), Ds(), $e = !1;
+}
+var vi = class {
+  constructor(t, e, i, n, s, o = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...t], this.onComplete = e, this.name = i, this.motionValue = n, this.element = s, this.isAsync = o;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (mt.add(this), Ue || (Ue = !0, M.read(Es), M.resolveKeyframes(Ds))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: t, name: e, element: i, motionValue: n } = this;
+    if (t[0] === null) {
+      const s = n?.get(), o = t[t.length - 1];
+      if (s !== void 0) t[0] = s;
+      else if (i && e) {
+        const r = i.readValue(e, o);
+        r != null && (t[0] = r);
+      }
+      t[0] === void 0 && (t[0] = o), n && s === void 0 && n.set(t[0]);
+    }
+    Jo(t);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(t = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, t), mt.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (mt.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}, aa = (t) => t.startsWith("--");
+function Rs(t, e, i) {
+  aa(e) ? t.style.setProperty(e, i) : t.style[e] = i;
+}
+var la = {};
+function Ls(t, e) {
+  const i = /* @__PURE__ */ ss(t);
+  return () => la[e] ?? i();
+}
+var ua = /* @__PURE__ */ Ls(() => window.ScrollTimeline !== void 0, "scrollTimeline"), ks = /* @__PURE__ */ Ls(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing"), Lt = ([t, e, i, n]) => `cubic-bezier(${t}, ${e}, ${i}, ${n})`, zi = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ Lt([
+    0,
+    0.65,
+    0.55,
+    1
+  ]),
+  circOut: /* @__PURE__ */ Lt([
+    0.55,
+    0,
+    1,
+    0.45
+  ]),
+  backIn: /* @__PURE__ */ Lt([
+    0.31,
+    0.01,
+    0.66,
+    -0.59
+  ]),
+  backOut: /* @__PURE__ */ Lt([
+    0.33,
+    1.53,
+    0.69,
+    0.99
+  ])
+};
+function Bs(t, e) {
+  if (t) return typeof t == "function" ? ks() ? As(t, e) : "ease-out" : ms(t) ? Lt(t) : Array.isArray(t) ? t.map((i) => Bs(i, e) || zi.easeOut) : zi[t];
+}
+function ca(t, e, i, { delay: n = 0, duration: s = 300, repeat: o = 0, repeatType: r = "loop", ease: a = "easeOut", times: l } = {}, c = void 0) {
+  const u = { [e]: i };
+  l && (u.offset = l);
+  const h = Bs(a, s);
+  Array.isArray(h) && (u.easing = h);
+  const f = {
+    delay: n,
+    duration: s,
+    easing: Array.isArray(h) ? "linear" : h,
+    fill: "both",
+    iterations: o + 1,
+    direction: r === "reverse" ? "alternate" : "normal"
+  };
+  return c && (f.pseudoElement = c), t.animate(u, f);
+}
+function Is(t) {
+  return typeof t == "function" && "applyToOptions" in t;
+}
+function ha({ type: t, ...e }) {
+  return Is(t) && ks() ? t.applyToOptions(e) : (e.duration ?? (e.duration = 300), e.ease ?? (e.ease = "easeOut"), e);
+}
+var Fs = class extends mi {
+  constructor(t) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !t) return;
+    const { element: e, name: i, keyframes: n, pseudoElement: s, allowFlatten: o = !1, finalKeyframe: r, onComplete: a } = t;
+    this.isPseudoElement = !!s, this.allowFlatten = o, this.options = t, it(typeof t.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
+    const l = ha(t);
+    this.animation = ca(e, i, n, l, s), l.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !s) {
+        const c = fe(n, this.options, r, this.speed);
+        this.updateMotionValue && this.updateMotionValue(c), Rs(e, i, c), this.animation.cancel();
+      }
+      a?.(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.finish?.();
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped) return;
+    this.isStopped = !0;
+    const { state: t } = this;
+    t === "idle" || t === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+  }
+  commitStyles() {
+    const t = this.options?.element;
+    !this.isPseudoElement && t?.isConnected && this.animation.commitStyles?.();
+  }
+  get duration() {
+    const t = this.animation.effect?.getComputedTiming?.().duration || 0;
+    return K(Number(t));
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + K(t);
+  }
+  get time() {
+    return K(Number(this.animation.currentTime) || 0);
+  }
+  set time(t) {
+    const e = this.finishedTime !== null;
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = W(t), e && this.animation.pause();
+  }
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(t) {
+    t < 0 && (this.finishedTime = null), this.animation.playbackRate = t;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(t) {
+    this.manualStartTime = this.animation.startTime = t;
+  }
+  attachTimeline({ timeline: t, rangeStart: e, rangeEnd: i, observe: n }) {
+    return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, t && ua() ? (this.animation.timeline = t, e && (this.animation.rangeStart = e), i && (this.animation.rangeEnd = i), _) : n(this);
+  }
+}, Os = {
+  anticipate: hs,
+  backInOut: cs,
+  circInOut: ds
+};
+function fa(t) {
+  return t in Os;
+}
+function da(t) {
+  typeof t.ease == "string" && fa(t.ease) && (t.ease = Os[t.ease]);
+}
+var xe = 10, pa = class extends Fs {
+  constructor(t) {
+    da(t), Cs(t), super(t), t.startTime !== void 0 && t.autoplay !== !1 && (this.startTime = t.startTime), this.options = t;
+  }
+  updateMotionValue(t) {
+    const { motionValue: e, onUpdate: i, onComplete: n, element: s, ...o } = this.options;
+    if (!e) return;
+    if (t !== void 0) {
+      e.set(t);
+      return;
+    }
+    const r = new re({
+      ...o,
+      autoplay: !1
+    }), a = Math.max(xe, O.now() - this.startTime), l = Q(0, xe, a - xe), c = r.sample(a).value, { name: u } = this.options;
+    s && u && Rs(s, u, c), e.setWithVelocity(r.sample(Math.max(0, a - l)).value, c, l), r.stop();
+  }
+}, Hi = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && (G.test(t) || t === "0") && !t.startsWith("url("));
+function ma(t) {
+  const e = t[0];
+  if (t.length === 1) return !0;
+  for (let i = 0; i < t.length; i++) if (t[i] !== e) return !0;
+}
+function va(t, e, i, n) {
+  const s = t[0];
+  if (s === null) return !1;
+  if (e === "display" || e === "visibility") return !0;
+  const o = t[t.length - 1], r = Hi(s, e), a = Hi(o, e);
+  return Mt(r === a, `You are trying to animate ${e} from "${s}" to "${o}". "${r ? o : s}" is not an animatable value.`, "value-not-animatable"), !r || !a ? !1 : ma(t) || (i === "spring" || Is(i)) && n;
+}
+function Ke(t) {
+  t.duration = 0, t.type = "keyframes";
+}
+var js = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+]), ga = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/;
+function ya(t) {
+  for (let e = 0; e < t.length; e++) if (typeof t[e] == "string" && ga.test(t[e])) return !0;
+  return !1;
+}
+var Ta = /* @__PURE__ */ new Set([
+  "color",
+  "backgroundColor",
+  "outlineColor",
+  "fill",
+  "stroke",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor"
+]), xa = /* @__PURE__ */ ss(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function wa(t) {
+  const { motionValue: e, name: i, repeatDelay: n, repeatType: s, damping: o, type: r, keyframes: a } = t;
+  if (!(e?.owner?.current instanceof HTMLElement)) return !1;
+  const { onUpdate: l, transformTemplate: c } = e.owner.getProps();
+  return xa() && i && (js.has(i) || Ta.has(i) && ya(a)) && (i !== "transform" || !c) && !l && !n && s !== "mirror" && o !== 0 && r !== "inertia";
+}
+var Pa = 40, Sa = class extends mi {
+  constructor({ autoplay: t = !0, delay: e = 0, type: i = "keyframes", repeat: n = 0, repeatDelay: s = 0, repeatType: o = "loop", keyframes: r, name: a, motionValue: l, element: c, ...u }) {
+    super(), this.stop = () => {
+      this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+    }, this.createdAt = O.now();
+    const h = {
+      autoplay: t,
+      delay: e,
+      type: i,
+      repeat: n,
+      repeatDelay: s,
+      repeatType: o,
+      name: a,
+      motionValue: l,
+      element: c,
+      ...u
+    }, f = c?.KeyframeResolver || vi;
+    this.keyframeResolver = new f(r, (p, d, m) => this.onKeyframesResolved(p, d, h, !m), a, l, c), this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(t, e, i, n) {
+    this.keyframeResolver = void 0;
+    const { name: s, type: o, velocity: r, delay: a, isHandoff: l, onUpdate: c } = i;
+    this.resolvedAt = O.now();
+    let u = !0;
+    va(t, s, o, r) || (u = !1, (st.instantAnimations || !a) && c?.(fe(t, i, e)), t[0] = t[t.length - 1], Ke(i), i.repeat = 0);
+    const h = {
+      startTime: n ? this.resolvedAt ? this.resolvedAt - this.createdAt > Pa ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: e,
+      ...i,
+      keyframes: t
+    }, f = u && !l && wa(h), p = h.motionValue?.owner?.current;
+    let d;
+    if (f) try {
+      d = new pa({
+        ...h,
+        element: p
+      });
+    } catch {
+      d = new re(h);
+    }
+    else d = new re(h);
+    d.finished.then(() => {
+      this.notifyFinished();
+    }).catch(_), this.pendingTimeline && (this.stopTimeline = d.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = d;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(t, e) {
+    return this.finished.finally(t).then(() => {
+    });
+  }
+  get animation() {
+    return this._animation || (this.keyframeResolver?.resume(), oa()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(t) {
+    this.animation.time = t;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(t) {
+    this.animation.speed = t;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(t) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(t) : this.pendingTimeline = t, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+  }
+};
+function Ns(t, e, i, n = 0, s = 1) {
+  const o = Array.from(t).sort((l, c) => l.sortNodePosition(c)).indexOf(e), r = t.size, a = (r - 1) * n;
+  return typeof i == "function" ? i(o, r) : s === 1 ? o * n : a - o * n;
+}
+var Gi = 30, ba = (t) => !isNaN(parseFloat(t)), Xi = { current: void 0 }, Aa = class {
+  constructor(t, e = {}) {
+    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (i) => {
+      const n = O.now();
+      if (this.updatedAt !== n && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(i), this.current !== this.prev && (this.events.change?.notify(this.current), this.dependents))
+        for (const s of this.dependents) s.dirty();
+    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner;
+  }
+  setCurrent(t) {
+    this.current = t, this.updatedAt = O.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = ba(this.current));
+  }
+  setPrevFrameValue(t = this.current) {
+    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  }
+  onChange(t) {
+    return process.env.NODE_ENV !== "production" && ai(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", t);
+  }
+  on(t, e) {
+    this.events[t] || (this.events[t] = new oi());
+    const i = this.events[t].add(e);
+    return t === "change" ? () => {
+      i(), M.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : i;
+  }
+  clearListeners() {
+    for (const t in this.events) this.events[t].clear();
+  }
+  attach(t, e) {
+    this.passiveEffect = t, this.stopPassiveEffect = e;
+  }
+  set(t) {
+    this.passiveEffect ? this.passiveEffect(t, this.updateAndNotify) : this.updateAndNotify(t);
+  }
+  setWithVelocity(t, e, i) {
+    this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - i;
+  }
+  jump(t, e = !0) {
+    this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, e && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  dirty() {
+    this.events.change?.notify(this.current);
+  }
+  addDependent(t) {
+    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(t);
+  }
+  removeDependent(t) {
+    this.dependents && this.dependents.delete(t);
+  }
+  get() {
+    return Xi.current && Xi.current.push(this), this.current;
+  }
+  getPrevious() {
+    return this.prev;
+  }
+  getVelocity() {
+    const t = O.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > Gi) return 0;
+    const e = Math.min(this.updatedAt - this.prevUpdatedAt, Gi);
+    return rs(parseFloat(this.current) - parseFloat(this.prevFrameValue), e);
+  }
+  start(t) {
+    return this.stop(), new Promise((e) => {
+      this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  destroy() {
+    this.dependents?.clear(), this.events.destroy?.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+};
+function At(t, e) {
+  return new Aa(t, e);
+}
+function Us(t, e) {
+  if (t?.inherit && e) {
+    const { inherit: i, ...n } = t;
+    return {
+      ...e,
+      ...n
+    };
+  }
+  return t;
+}
+function gi(t, e) {
+  const i = t?.[e] ?? t?.default ?? t;
+  return i !== t ? Us(i, t) : i;
+}
+var Va = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, Ma = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), Ca = {
+  type: "keyframes",
+  duration: 0.8
+}, Da = {
+  type: "keyframes",
+  ease: [
+    0.25,
+    0.1,
+    0.35,
+    1
+  ],
+  duration: 0.3
+}, Ea = (t, { keyframes: e }) => e.length > 2 ? Ca : Et.has(t) ? t.startsWith("scale") ? Ma(e[1]) : Va : Da, Ra = /* @__PURE__ */ new Set([
+  "when",
+  "delay",
+  "delayChildren",
+  "staggerChildren",
+  "staggerDirection",
+  "repeat",
+  "repeatType",
+  "repeatDelay",
+  "from",
+  "elapsed"
+]);
+function La(t) {
+  for (const e in t) if (!Ra.has(e)) return !0;
+  return !1;
+}
+var yi = (t, e, i, n = {}, s, o) => (r) => {
+  const a = gi(n, t) || {}, l = a.delay || n.delay || 0;
+  let { elapsed: c = 0 } = n;
+  c = c - W(l);
+  const u = {
+    keyframes: Array.isArray(i) ? i : [null, i],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...a,
+    delay: -c,
+    onUpdate: (f) => {
+      e.set(f), a.onUpdate && a.onUpdate(f);
+    },
+    onComplete: () => {
+      r(), a.onComplete && a.onComplete();
+    },
+    name: t,
+    motionValue: e,
+    element: o ? void 0 : s
+  };
+  La(a) || Object.assign(u, Ea(t, u)), u.duration && (u.duration = W(u.duration)), u.repeatDelay && (u.repeatDelay = W(u.repeatDelay)), u.from !== void 0 && (u.keyframes[0] = u.from);
+  let h = !1;
+  if ((u.type === !1 || u.duration === 0 && !u.repeatDelay) && (Ke(u), u.delay === 0 && (h = !0)), (st.instantAnimations || st.skipAnimations || s?.shouldSkipAnimations || a.skipAnimations) && (h = !0, Ke(u), u.delay = 0), u.allowFlatten = !a.type && !a.ease, h && !o && e.get() !== void 0) {
+    const f = fe(u.keyframes, a);
+    if (f !== void 0) {
+      M.update(() => {
+        u.onUpdate(f), u.onComplete();
+      });
+      return;
+    }
+  }
+  return a.isSync ? new re(u) : new Sa(u);
+}, ka = /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u;
+function Ba(t) {
+  const e = ka.exec(t);
+  if (!e) return [,];
+  const [, i, n, s] = e;
+  return [`--${i ?? n}`, s];
+}
+var Ia = 4;
+function Ws(t, e, i = 1) {
+  it(i <= Ia, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [n, s] = Ba(t);
+  if (!n) return;
+  const o = window.getComputedStyle(e).getPropertyValue(n);
+  if (o) {
+    const r = o.trim();
+    return es(r) ? parseFloat(r) : r;
+  }
+  return ci(s) ? Ws(s, e, i + 1) : s;
+}
+function Yi(t) {
+  const e = [{}, {}];
+  return t?.values.forEach((i, n) => {
+    e[0][n] = i.get(), e[1][n] = i.getVelocity();
+  }), e;
+}
+function Ti(t, e, i, n) {
+  if (typeof e == "function") {
+    const [s, o] = Yi(n);
+    e = e(i !== void 0 ? i : t.custom, s, o);
+  }
+  if (typeof e == "string" && (e = t.variants && t.variants[e]), typeof e == "function") {
+    const [s, o] = Yi(n);
+    e = e(i !== void 0 ? i : t.custom, s, o);
+  }
+  return e;
+}
+function vt(t, e, i) {
+  const n = t.getProps();
+  return Ti(n, e, i !== void 0 ? i : n.custom, t);
+}
+var $s = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...Dt
+]), _e = (t) => Array.isArray(t);
+function Fa(t, e, i) {
+  t.hasValue(e) ? t.getValue(e).set(i) : t.addValue(e, At(i));
+}
+function Oa(t) {
+  return _e(t) ? t[t.length - 1] || 0 : t;
+}
+function ja(t, e) {
+  let { transitionEnd: i = {}, transition: n = {}, ...s } = vt(t, e) || {};
+  s = {
+    ...s,
+    ...i
+  };
+  for (const o in s) Fa(t, o, Oa(s[o]));
+}
+var F = (t) => !!(t && t.getVelocity);
+function Na(t) {
+  return !!(F(t) && t.add);
+}
+function ze(t, e) {
+  const i = t.getValue("willChange");
+  if (Na(i)) return i.add(e);
+  if (!i && st.WillChange) {
+    const n = new st.WillChange("auto");
+    t.addValue("willChange", n), n.add(e);
+  }
+}
+function xi(t) {
+  return t.replace(/([A-Z])/g, (e) => `-${e.toLowerCase()}`);
+}
+var Ua = "framerAppearId", Ks = "data-" + xi(Ua);
+function _s(t) {
+  return t.props[Ks];
+}
+function Wa({ protectedKeys: t, needsAnimating: e }, i) {
+  const n = t.hasOwnProperty(i) && e[i] !== !0;
+  return e[i] = !1, n;
+}
+function zs(t, e, { delay: i = 0, transitionOverride: n, type: s } = {}) {
+  let { transition: o, transitionEnd: r, ...a } = e;
+  const l = t.getDefaultTransition();
+  o = o ? Us(o, l) : l;
+  const c = o?.reduceMotion, u = o?.skipAnimations;
+  n && (o = n);
+  const h = [], f = s && t.animationState && t.animationState.getState()[s], p = o?.path;
+  p && p.animateVisualElement(t, a, o, i, h);
+  for (const d in a) {
+    const m = t.getValue(d, t.latestValues[d] ?? null), v = a[d];
+    if (v === void 0 || f && Wa(f, d)) continue;
+    const g = {
+      delay: i,
+      ...gi(o || {}, d)
+    };
+    u && (g.skipAnimations = !0);
+    const T = m.get();
+    if (T !== void 0 && !m.isAnimating() && !Array.isArray(v) && v === T && !g.velocity) {
+      M.update(() => m.set(v));
+      continue;
+    }
+    let x = !1;
+    if (window.MotionHandoffAnimation) {
+      const A = _s(t);
+      if (A) {
+        const D = window.MotionHandoffAnimation(A, d, M);
+        D !== null && (g.startTime = D, x = !0);
+      }
+    }
+    ze(t, d);
+    const w = c ?? t.shouldReduceMotion;
+    m.start(yi(d, m, v, w && $s.has(d) ? { type: !1 } : g, t, x));
+    const P = m.animation;
+    P && h.push(P);
+  }
+  if (r) {
+    const d = () => M.update(() => {
+      r && ja(t, r);
+    });
+    h.length ? Promise.all(h).then(d) : d();
+  }
+  return h;
+}
+function He(t, e, i = {}) {
+  const n = vt(t, e, i.type === "exit" ? t.presenceContext?.custom : void 0);
+  let { transition: s = t.getDefaultTransition() || {} } = n || {};
+  i.transitionOverride && (s = i.transitionOverride);
+  const o = n ? () => Promise.all(zs(t, n, i)) : () => Promise.resolve(), r = t.variantChildren && t.variantChildren.size ? (l = 0) => {
+    const { delayChildren: c = 0, staggerChildren: u, staggerDirection: h } = s;
+    return $a(t, e, l, c, u, h, i);
+  } : () => Promise.resolve(), { when: a } = s;
+  if (a) {
+    const [l, c] = a === "beforeChildren" ? [o, r] : [r, o];
+    return l().then(() => c());
+  } else return Promise.all([o(), r(i.delay)]);
+}
+function $a(t, e, i = 0, n = 0, s = 0, o = 1, r) {
+  const a = [];
+  for (const l of t.variantChildren)
+    l.notify("AnimationStart", e), a.push(He(l, e, {
+      ...r,
+      delay: i + (typeof n == "function" ? 0 : n) + Ns(t.variantChildren, l, n, s, o)
+    }).then(() => l.notify("AnimationComplete", e)));
+  return Promise.all(a);
+}
+function Ka(t, e, i = {}) {
+  t.notify("AnimationStart", e);
+  let n;
+  if (Array.isArray(e)) {
+    const s = e.map((o) => He(t, o, i));
+    n = Promise.all(s);
+  } else if (typeof e == "string") n = He(t, e, i);
+  else {
+    const s = typeof e == "function" ? vt(t, e, i.custom) : e;
+    n = Promise.all(zs(t, s, i));
+  }
+  return n.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+var _a = {
+  test: (t) => t === "auto",
+  parse: (t) => t
+}, Hs = (t) => (e) => e.test(t), Gs = [
+  Ct,
+  y,
+  J,
+  et,
+  mo,
+  po,
+  _a
+], qi = (t) => Gs.find(Hs(t));
+function za(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || ns(t) : !0;
+}
+var Ha = /* @__PURE__ */ new Set([
+  "brightness",
+  "contrast",
+  "saturate",
+  "opacity"
+]);
+function Ga(t) {
+  const [e, i] = t.slice(0, -1).split("(");
+  if (e === "drop-shadow") return t;
+  const [n] = i.match(hi) || [];
+  if (!n) return t;
+  const s = i.replace(n, "");
+  let o = Ha.has(e) ? 1 : 0;
+  return n !== i && (o *= 100), e + "(" + o + s + ")";
+}
+var Xa = /\b([a-z-]*)\(.*?\)/gu, Ge = {
+  ...G,
+  getAnimatableNone: (t) => {
+    const e = t.match(Xa);
+    return e ? e.map(Ga).join(" ") : t;
+  }
+}, Xe = {
+  ...G,
+  getAnimatableNone: (t) => {
+    const e = G.parse(t);
+    return G.createTransformer(t)(e.map((i) => typeof i == "number" ? 0 : typeof i == "object" ? {
+      ...i,
+      alpha: 1
+    } : i));
+  }
+}, Zi = {
+  ...Ct,
+  transform: Math.round
+}, Ya = {
+  rotate: et,
+  pathRotation: et,
+  rotateX: et,
+  rotateY: et,
+  rotateZ: et,
+  scale: zt,
+  scaleX: zt,
+  scaleY: zt,
+  scaleZ: zt,
+  skew: et,
+  skewX: et,
+  skewY: et,
+  distance: y,
+  translateX: y,
+  translateY: y,
+  translateZ: y,
+  x: y,
+  y,
+  z: y,
+  perspective: y,
+  transformPerspective: y,
+  opacity: Ot,
+  originX: Ii,
+  originY: Ii,
+  originZ: y
+}, oe = {
+  borderWidth: y,
+  borderTopWidth: y,
+  borderRightWidth: y,
+  borderBottomWidth: y,
+  borderLeftWidth: y,
+  borderRadius: y,
+  borderTopLeftRadius: y,
+  borderTopRightRadius: y,
+  borderBottomRightRadius: y,
+  borderBottomLeftRadius: y,
+  width: y,
+  maxWidth: y,
+  height: y,
+  maxHeight: y,
+  top: y,
+  right: y,
+  bottom: y,
+  left: y,
+  inset: y,
+  insetBlock: y,
+  insetBlockStart: y,
+  insetBlockEnd: y,
+  insetInline: y,
+  insetInlineStart: y,
+  insetInlineEnd: y,
+  padding: y,
+  paddingTop: y,
+  paddingRight: y,
+  paddingBottom: y,
+  paddingLeft: y,
+  paddingBlock: y,
+  paddingBlockStart: y,
+  paddingBlockEnd: y,
+  paddingInline: y,
+  paddingInlineStart: y,
+  paddingInlineEnd: y,
+  margin: y,
+  marginTop: y,
+  marginRight: y,
+  marginBottom: y,
+  marginLeft: y,
+  marginBlock: y,
+  marginBlockStart: y,
+  marginBlockEnd: y,
+  marginInline: y,
+  marginInlineStart: y,
+  marginInlineEnd: y,
+  fontSize: y,
+  backgroundPositionX: y,
+  backgroundPositionY: y,
+  ...Ya,
+  zIndex: Zi,
+  fillOpacity: Ot,
+  strokeOpacity: Ot,
+  numOctaves: Zi
+}, qa = {
+  ...oe,
+  color: R,
+  backgroundColor: R,
+  outlineColor: R,
+  fill: R,
+  stroke: R,
+  borderColor: R,
+  borderTopColor: R,
+  borderRightColor: R,
+  borderBottomColor: R,
+  borderLeftColor: R,
+  filter: Ge,
+  WebkitFilter: Ge,
+  mask: Xe,
+  WebkitMask: Xe
+}, Xs = (t) => qa[t], Za = /* @__PURE__ */ new Set([Ge, Xe]);
+function Ys(t, e) {
+  let i = Xs(t);
+  return Za.has(i) || (i = G), i.getAnimatableNone ? i.getAnimatableNone(e) : void 0;
+}
+var Ja = /* @__PURE__ */ new Set([
+  "auto",
+  "none",
+  "0"
+]);
+function Qa(t, e, i) {
+  let n = 0, s;
+  for (; n < t.length && !s; ) {
+    const o = t[n];
+    typeof o == "string" && !Ja.has(o) && bt(o).values.length && (s = t[n]), n++;
+  }
+  if (s && i) for (const o of e) t[o] = Ys(i, s);
+}
+var tl = class extends vi {
+  constructor(t, e, i, n, s) {
+    super(t, e, i, n, s, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: t, element: e, name: i } = this;
+    if (!e || !e.current) return;
+    super.readKeyframes();
+    for (let a = 0; a < t.length; a++) {
+      let l = t[a];
+      if (typeof l == "string" && (l = l.trim(), ci(l))) {
+        const c = Ws(l, e.current);
+        c !== void 0 && (t[a] = c), a === t.length - 1 && (this.finalKeyframe = l);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !$s.has(i) || t.length !== 2) return;
+    const [n, s] = t, o = qi(n), r = qi(s);
+    if (Bi(n) !== Bi(s) && nt[i]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (o !== r)
+      if (_i(o) && _i(r)) for (let a = 0; a < t.length; a++) {
+        const l = t[a];
+        typeof l == "string" && (t[a] = parseFloat(l));
+      }
+      else nt[i] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: t, name: e } = this, i = [];
+    for (let n = 0; n < t.length; n++) (t[n] === null || za(t[n])) && i.push(n);
+    i.length && Qa(t, i, e);
+  }
+  measureInitialState() {
+    const { element: t, unresolvedKeyframes: e, name: i } = this;
+    if (!t || !t.current) return;
+    i === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = nt[i](t.measureViewportBox(), window.getComputedStyle(t.current)), e[0] = this.measuredOrigin;
+    const n = e[e.length - 1];
+    n !== void 0 && t.getValue(i, n).jump(n, !1);
+  }
+  measureEndState() {
+    const { element: t, name: e, unresolvedKeyframes: i } = this;
+    if (!t || !t.current) return;
+    const n = t.getValue(e);
+    n && n.jump(this.measuredOrigin, !1);
+    const s = i.length - 1, o = i[s];
+    i[s] = nt[e](t.measureViewportBox(), window.getComputedStyle(t.current)), o !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = o), this.removedTransforms?.length && this.removedTransforms.forEach(([r, a]) => {
+      t.getValue(r).set(a);
+    }), this.resolveNoneKeyframes();
+  }
+}, wi = [
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomRightRadius",
+  "borderBottomLeftRadius"
+];
+function qs(t, e, i) {
+  if (t == null) return [];
+  if (t instanceof EventTarget) return [t];
+  if (typeof t == "string") {
+    let n = document;
+    e && (n = e.current);
+    const s = i?.[t] ?? n.querySelectorAll(t);
+    return s ? Array.from(s) : [];
+  }
+  return Array.from(t).filter((n) => n != null);
+}
+var Ye = (t, e) => e && typeof t == "number" ? e.transform(t) : t;
+function el(t) {
+  return is(t) && "offsetHeight" in t && !("ownerSVGElement" in t);
+}
+var { schedule: Pi, cancel: qc } = /* @__PURE__ */ vs(queueMicrotask, !1), H = {
+  x: !1,
+  y: !1
+};
+function Zs() {
+  return H.x || H.y;
+}
+function il(t) {
+  return t === "x" || t === "y" ? H[t] ? null : (H[t] = !0, () => {
+    H[t] = !1;
+  }) : H.x || H.y ? null : (H.x = H.y = !0, () => {
+    H.x = H.y = !1;
+  });
+}
+function Js(t, e) {
+  const i = qs(t), n = new AbortController(), s = {
+    passive: !0,
+    ...e,
+    signal: n.signal
+  };
+  return [
+    i,
+    s,
+    () => n.abort()
+  ];
+}
+function nl(t) {
+  return !(t.pointerType === "touch" || Zs());
+}
+function sl(t, e, i = {}) {
+  const [n, s, o] = Js(t, i);
+  return n.forEach((r) => {
+    let a = !1, l = !1, c;
+    const u = () => {
+      r.removeEventListener("pointerleave", d);
+    }, h = (v) => {
+      c && (c(v), c = void 0), u();
+    }, f = (v) => {
+      a = !1, window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", f), l && (l = !1, h(v));
+    }, p = () => {
+      a = !0, window.addEventListener("pointerup", f, s), window.addEventListener("pointercancel", f, s);
+    }, d = (v) => {
+      if (v.pointerType !== "touch") {
+        if (a) {
+          l = !0;
+          return;
+        }
+        h(v);
+      }
+    }, m = (v) => {
+      if (!nl(v)) return;
+      l = !1;
+      const g = e(r, v);
+      typeof g == "function" && (c = g, r.addEventListener("pointerleave", d, s));
+    };
+    r.addEventListener("pointerenter", m, s), r.addEventListener("pointerdown", p, s);
+  }), o;
+}
+var Qs = (t, e) => e ? t === e ? !0 : Qs(t, e.parentElement) : !1, Si = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, rl = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function ol(t) {
+  return rl.has(t.tagName) || t.isContentEditable === !0;
+}
+var al = /* @__PURE__ */ new Set([
+  "INPUT",
+  "SELECT",
+  "TEXTAREA"
+]);
+function ll(t) {
+  return al.has(t.tagName) || t.isContentEditable === !0;
+}
+var Yt = /* @__PURE__ */ new WeakSet();
+function Ji(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function we(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, {
+    isPrimary: !0,
+    bubbles: !0
+  }));
+}
+var ul = (t, e) => {
+  const i = t.currentTarget;
+  if (!i) return;
+  const n = Ji(() => {
+    if (Yt.has(i)) return;
+    we(i, "down");
+    const s = Ji(() => {
+      we(i, "up");
+    }), o = () => we(i, "cancel");
+    i.addEventListener("keyup", s, e), i.addEventListener("blur", o, e);
+  });
+  i.addEventListener("keydown", n, e), i.addEventListener("blur", () => i.removeEventListener("keydown", n), e);
+};
+function Qi(t) {
+  return Si(t) && !Zs();
+}
+var tn = /* @__PURE__ */ new WeakSet();
+function cl(t, e, i = {}) {
+  const [n, s, o] = Js(t, i), r = (a) => {
+    const l = a.currentTarget;
+    if (!Qi(a) || tn.has(a)) return;
+    Yt.add(l), i.stopPropagation && tn.add(a);
+    const c = e(l, a), u = {
+      ...s,
+      capture: !0
+    }, h = (d, m) => {
+      window.removeEventListener("pointerup", f, u), window.removeEventListener("pointercancel", p, u), Yt.has(l) && Yt.delete(l), Qi(d) && typeof c == "function" && c(d, { success: m });
+    }, f = (d) => {
+      h(d, l === window || l === document || i.useGlobalTarget || Qs(l, d.target));
+    }, p = (d) => {
+      h(d, !1);
+    };
+    window.addEventListener("pointerup", f, u), window.addEventListener("pointercancel", p, u);
+  };
+  return n.forEach((a) => {
+    (i.useGlobalTarget ? window : a).addEventListener("pointerdown", r, s), el(a) && (a.addEventListener("focus", (l) => ul(l, s)), !ol(a) && !a.hasAttribute("tabindex") && (a.tabIndex = 0));
+  }), o;
+}
+function bi(t) {
+  return is(t) && "ownerSVGElement" in t;
+}
+var qt = /* @__PURE__ */ new WeakMap(), Zt, tr = (t, e, i) => (n, s) => s && s[0] ? s[0][t + "Size"] : bi(n) && "getBBox" in n ? n.getBBox()[e] : n[i], hl = /* @__PURE__ */ tr("inline", "width", "offsetWidth"), fl = /* @__PURE__ */ tr("block", "height", "offsetHeight");
+function dl({ target: t, borderBoxSize: e }) {
+  qt.get(t)?.forEach((i) => {
+    i(t, {
+      get width() {
+        return hl(t, e);
+      },
+      get height() {
+        return fl(t, e);
+      }
+    });
+  });
+}
+function pl(t) {
+  t.forEach(dl);
+}
+function ml() {
+  typeof ResizeObserver > "u" || (Zt = new ResizeObserver(pl));
+}
+function vl(t, e) {
+  Zt || ml();
+  const i = qs(t);
+  return i.forEach((n) => {
+    let s = qt.get(n);
+    s || (s = /* @__PURE__ */ new Set(), qt.set(n, s)), s.add(e), Zt?.observe(n);
+  }), () => {
+    i.forEach((n) => {
+      const s = qt.get(n);
+      s?.delete(e), s?.size || Zt?.unobserve(n);
+    });
+  };
+}
+var Jt = /* @__PURE__ */ new Set(), Pt;
+function gl() {
+  Pt = () => {
+    const t = {
+      get width() {
+        return window.innerWidth;
+      },
+      get height() {
+        return window.innerHeight;
+      }
+    };
+    Jt.forEach((e) => e(t));
+  }, window.addEventListener("resize", Pt);
+}
+function yl(t) {
+  return Jt.add(t), Pt || gl(), () => {
+    Jt.delete(t), !Jt.size && typeof Pt == "function" && (window.removeEventListener("resize", Pt), Pt = void 0);
+  };
+}
+function en(t, e) {
+  return typeof t == "function" ? yl(t) : vl(t, e);
+}
+var yt = {
+  value: null,
+  addProjectionMetrics: null
+};
+function Tl(t) {
+  return bi(t) && t.tagName === "svg";
+}
+var xl = [
+  ...Gs,
+  R,
+  G
+], wl = (t) => xl.find(Hs(t)), nn = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), St = () => ({
+  x: nn(),
+  y: nn()
+}), sn = () => ({
+  min: 0,
+  max: 0
+}), L = () => ({
+  x: sn(),
+  y: sn()
+}), Pl = /* @__PURE__ */ new WeakMap();
+function de(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+function jt(t) {
+  return typeof t == "string" || Array.isArray(t);
+}
+var Ai = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], Vi = ["initial", ...Ai];
+function pe(t) {
+  return de(t.animate) || Vi.some((e) => jt(t[e]));
+}
+function er(t) {
+  return !!(pe(t) || t.variants);
+}
+function Sl(t, e, i) {
+  for (const n in e) {
+    const s = e[n], o = i[n];
+    if (F(s)) t.addValue(n, s);
+    else if (F(o)) t.addValue(n, At(s, { owner: t }));
+    else if (o !== s) if (t.hasValue(n)) {
+      const r = t.getValue(n);
+      r.liveStyle === !0 ? r.jump(s) : r.hasAnimated || r.set(s);
+    } else {
+      const r = t.getStaticValue(n);
+      t.addValue(n, At(r !== void 0 ? r : s, { owner: t }));
+    }
+  }
+  for (const n in i) e[n] === void 0 && t.removeValue(n);
+  return e;
+}
+var qe = { current: null }, ir = { current: !1 }, bl = typeof window < "u";
+function Al() {
+  if (ir.current = !0, !!bl)
+    if (window.matchMedia) {
+      const t = window.matchMedia("(prefers-reduced-motion)"), e = () => qe.current = t.matches;
+      t.addEventListener("change", e), e();
+    } else qe.current = !1;
+}
+var rn = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+], ae = {};
+function nr(t) {
+  ae = t;
+}
+function Vl() {
+  return ae;
+}
+var Ml = class {
+  scrapeMotionValuesFromProps(t, e, i) {
+    return {};
+  }
+  constructor({ parent: t, props: e, presenceContext: i, reducedMotionConfig: n, skipAnimations: s, blockInitialAnimation: o, visualState: r }, a = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.shouldSkipAnimations = !1, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = vi, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.hasBeenMounted = !1, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const f = O.now();
+      this.renderScheduledAt < f && (this.renderScheduledAt = f, M.render(this.render, !1, !0));
+    };
+    const { latestValues: l, renderState: c } = r;
+    this.latestValues = l, this.baseTarget = { ...l }, this.initialValues = e.initial ? { ...l } : {}, this.renderState = c, this.parent = t, this.props = e, this.presenceContext = i, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = n, this.skipAnimationsConfig = s, this.options = a, this.blockInitialAnimation = !!o, this.isControllingVariants = pe(e), this.isVariantNode = er(e), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: u, ...h } = this.scrapeMotionValuesFromProps(e, {}, this);
+    for (const f in h) {
+      const p = h[f];
+      l[f] !== void 0 && F(p) && p.set(l[f]);
+    }
+  }
+  mount(t) {
+    if (this.hasBeenMounted) for (const e in this.initialValues)
+      this.values.get(e)?.jump(this.initialValues[e]), this.latestValues[e] = this.initialValues[e];
+    this.current = t, Pl.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((e, i) => this.bindToMotionValue(i, e)), this.reducedMotionConfig === "never" ? this.shouldReduceMotion = !1 : this.reducedMotionConfig === "always" ? this.shouldReduceMotion = !0 : (ir.current || Al(), this.shouldReduceMotion = qe.current), process.env.NODE_ENV !== "production" && ai(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled"), this.shouldSkipAnimations = this.skipAnimationsConfig ?? !1, this.parent?.addChild(this), this.update(this.props, this.presenceContext), this.hasBeenMounted = !0;
+  }
+  unmount() {
+    this.projection && this.projection.unmount(), rt(this.notifyUpdate), rt(this.render), this.valueSubscriptions.forEach((t) => t()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent?.removeChild(this);
+    for (const t in this.events) this.events[t].clear();
+    for (const t in this.features) {
+      const e = this.features[t];
+      e && (e.unmount(), e.isMounted = !1);
+    }
+    this.current = null;
+  }
+  addChild(t) {
+    this.children.add(t), this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set()), this.enteringChildren.add(t);
+  }
+  removeChild(t) {
+    this.children.delete(t), this.enteringChildren && this.enteringChildren.delete(t);
+  }
+  bindToMotionValue(t, e) {
+    if (this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)(), e.accelerate && js.has(t) && this.current instanceof HTMLElement) {
+      const { factory: o, keyframes: r, times: a, ease: l, duration: c } = e.accelerate, u = new Fs({
+        element: this.current,
+        name: t,
+        keyframes: r,
+        times: a,
+        ease: l,
+        duration: W(c)
+      }), h = o(u);
+      this.valueSubscriptions.set(t, () => {
+        h(), u.cancel();
+      });
+      return;
+    }
+    const i = Et.has(t);
+    i && this.onBindTransform && this.onBindTransform();
+    const n = e.on("change", (o) => {
+      this.latestValues[t] = o, this.props.onUpdate && M.preRender(this.notifyUpdate), i && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender();
+    });
+    let s;
+    typeof window < "u" && window.MotionCheckAppearSync && (s = window.MotionCheckAppearSync(this, t, e)), this.valueSubscriptions.set(t, () => {
+      n(), s && s();
+    });
+  }
+  sortNodePosition(t) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== t.type ? 0 : this.sortInstanceNodePosition(this.current, t.current);
+  }
+  updateFeatures() {
+    let t = "animation";
+    for (t in ae) {
+      const e = ae[t];
+      if (!e) continue;
+      const { isEnabled: i, Feature: n } = e;
+      if (!this.features[t] && n && i(this.props) && (this.features[t] = new n(this)), this.features[t]) {
+        const s = this.features[t];
+        s.isMounted ? s.update() : (s.mount(), s.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : L();
+  }
+  getStaticValue(t) {
+    return this.latestValues[t];
+  }
+  setStaticValue(t, e) {
+    this.latestValues[t] = e;
+  }
+  update(t, e) {
+    (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = e;
+    for (let i = 0; i < rn.length; i++) {
+      const n = rn[i];
+      this.propEventSubscriptions[n] && (this.propEventSubscriptions[n](), delete this.propEventSubscriptions[n]);
+      const s = t["on" + n];
+      s && (this.propEventSubscriptions[n] = this.on(n, s));
+    }
+    this.prevMotionValues = Sl(this, this.scrapeMotionValuesFromProps(t, this.prevProps || {}, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  getVariant(t) {
+    return this.props.variants ? this.props.variants[t] : void 0;
+  }
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  addVariantChild(t) {
+    const e = this.getClosestVariantNode();
+    if (e)
+      return e.variantChildren && e.variantChildren.add(t), () => e.variantChildren.delete(t);
+  }
+  addValue(t, e) {
+    const i = this.values.get(t);
+    e !== i && (i && this.removeValue(t), this.bindToMotionValue(t, e), this.values.set(t, e), this.latestValues[t] = e.get());
+  }
+  removeValue(t) {
+    this.values.delete(t);
+    const e = this.valueSubscriptions.get(t);
+    e && (e(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState);
+  }
+  hasValue(t) {
+    return this.values.has(t);
+  }
+  getValue(t, e) {
+    if (this.props.values && this.props.values[t]) return this.props.values[t];
+    let i = this.values.get(t);
+    return i === void 0 && e !== void 0 && (i = At(e === null ? void 0 : e, { owner: this }), this.addValue(t, i)), i;
+  }
+  readValue(t, e) {
+    let i = this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : this.getBaseTargetFromProps(this.props, t) ?? this.readValueFromInstance(this.current, t, this.options);
+    return i != null && (typeof i == "string" && (es(i) || ns(i)) ? i = parseFloat(i) : !wl(i) && G.test(e) && (i = Ys(t, e)), this.setBaseTarget(t, F(i) ? i.get() : i)), F(i) ? i.get() : i;
+  }
+  setBaseTarget(t, e) {
+    this.baseTarget[t] = e;
+  }
+  getBaseTarget(t) {
+    const { initial: e } = this.props;
+    let i;
+    if (typeof e == "string" || typeof e == "object") {
+      const s = Ti(this.props, e, this.presenceContext?.custom);
+      s && (i = s[t]);
+    }
+    if (e && i !== void 0) return i;
+    const n = this.getBaseTargetFromProps(this.props, t);
+    return n !== void 0 && !F(n) ? n : this.initialValues[t] !== void 0 && i === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, e) {
+    return this.events[t] || (this.events[t] = new oi()), this.events[t].add(e);
+  }
+  notify(t, ...e) {
+    this.events[t] && this.events[t].notify(...e);
+  }
+  scheduleRenderMicrotask() {
+    Pi.render(this.render);
+  }
+}, sr = class extends Ml {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = tl;
+  }
+  sortInstanceNodePosition(t, e) {
+    return t.compareDocumentPosition(e) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(t, e) {
+    const i = t.style;
+    return i ? i[e] : void 0;
+  }
+  removeValueFromRenderState(t, { vars: e, style: i }) {
+    delete e[t], delete i[t];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: t } = this.props;
+    F(t) && (this.childSubscription = t.on("change", (e) => {
+      this.current && (this.current.textContent = `${e}`);
+    }));
+  }
+}, ot = class {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
+  }
+  update() {
+  }
+};
+function rr({ top: t, left: e, right: i, bottom: n }) {
+  return {
+    x: {
+      min: e,
+      max: i
+    },
+    y: {
+      min: t,
+      max: n
+    }
+  };
+}
+function Cl({ x: t, y: e }) {
+  return {
+    top: e.min,
+    right: t.max,
+    bottom: e.max,
+    left: t.min
+  };
+}
+function Dl(t, e) {
+  if (!e) return t;
+  const i = e({
+    x: t.left,
+    y: t.top
+  }), n = e({
+    x: t.right,
+    y: t.bottom
+  });
+  return {
+    top: i.y,
+    left: i.x,
+    bottom: n.y,
+    right: n.x
+  };
+}
+function Pe(t) {
+  return t === void 0 || t === 1;
+}
+function Ze({ scale: t, scaleX: e, scaleY: i }) {
+  return !Pe(t) || !Pe(e) || !Pe(i);
+}
+function ct(t) {
+  return Ze(t) || or(t) || t.z || t.rotate || t.rotateX || t.rotateY || t.skewX || t.skewY;
+}
+function or(t) {
+  return on(t.x) || on(t.y);
+}
+function on(t) {
+  return t && t !== "0%";
+}
+function le(t, e, i) {
+  return i + e * (t - i);
+}
+function an(t, e, i, n, s) {
+  return s !== void 0 && (t = le(t, s, n)), le(t, i, n) + e;
+}
+function Je(t, e = 0, i = 1, n, s) {
+  t.min = an(t.min, e, i, n, s), t.max = an(t.max, e, i, n, s);
+}
+function ar(t, { x: e, y: i }) {
+  Je(t.x, e.translate, e.scale, e.originPoint), Je(t.y, i.translate, i.scale, i.originPoint);
+}
+var ln = 0.999999999999, un = 1.0000000000001;
+function El(t, e, i, n = !1) {
+  const s = i.length;
+  if (!s) return;
+  e.x = e.y = 1;
+  let o, r;
+  for (let a = 0; a < s; a++) {
+    o = i[a], r = o.projectionDelta;
+    const { visualElement: l } = o.options;
+    l && l.props.style && l.props.style.display === "contents" || (n && o.options.layoutScroll && o.scroll && o !== o.root && (Z(t.x, -o.scroll.offset.x), Z(t.y, -o.scroll.offset.y)), r && (e.x *= r.x.scale, e.y *= r.y.scale, ar(t, r)), n && ct(o.latestValues) && Qt(t, o.latestValues, o.layout?.layoutBox));
+  }
+  e.x < un && e.x > ln && (e.x = 1), e.y < un && e.y > ln && (e.y = 1);
+}
+function Z(t, e) {
+  t.min += e, t.max += e;
+}
+function cn(t, e, i, n, s = 0.5) {
+  Je(t, e, i, V(t.min, t.max, s), n);
+}
+function hn(t, e) {
+  return typeof t == "string" ? parseFloat(t) / 100 * (e.max - e.min) : t;
+}
+function Qt(t, e, i) {
+  const n = i ?? t;
+  cn(t.x, hn(e.x, n.x), e.scaleX, e.scale, e.originX), cn(t.y, hn(e.y, n.y), e.scaleY, e.scale, e.originY);
+}
+function lr(t, e) {
+  return rr(Dl(t.getBoundingClientRect(), e));
+}
+function Rl(t, e, i) {
+  const n = lr(t, i), { scroll: s } = e;
+  return s && (Z(n.x, s.offset.x), Z(n.y, s.offset.y)), n;
+}
+var Ll = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, kl = Dt.length;
+function Bl(t, e, i) {
+  let n = "", s = !0;
+  for (let r = 0; r < kl; r++) {
+    const a = Dt[r], l = t[a];
+    if (l === void 0) continue;
+    let c = !0;
+    if (typeof l == "number") c = l === (a.startsWith("scale") ? 1 : 0);
+    else {
+      const u = parseFloat(l);
+      c = a.startsWith("scale") ? u === 1 : u === 0;
+    }
+    if (!c || i) {
+      const u = Ye(l, oe[a]);
+      if (!c) {
+        s = !1;
+        const h = Ll[a] || a;
+        n += `${h}(${u}) `;
+      }
+      i && (e[a] = u);
+    }
+  }
+  const o = t.pathRotation;
+  return o && (s = !1, n += `rotate(${Ye(o, oe.pathRotation)}) `), n = n.trim(), i ? n = i(e, s ? "" : n) : s && (n = "none"), n;
+}
+function Mi(t, e, i) {
+  const { style: n, vars: s, transformOrigin: o } = t;
+  let r = !1, a = !1;
+  for (const l in e) {
+    const c = e[l];
+    if (Et.has(l)) {
+      r = !0;
+      continue;
+    } else if (ys(l)) {
+      s[l] = c;
+      continue;
+    } else {
+      const u = Ye(c, oe[l]);
+      l.startsWith("origin") ? (a = !0, o[l] = u) : n[l] = u;
+    }
+  }
+  if (e.transform || (r || i ? n.transform = Bl(e, t.transform, i) : n.transform && (n.transform = "none")), a) {
+    const { originX: l = "50%", originY: c = "50%", originZ: u = 0 } = o;
+    n.transformOrigin = `${l} ${c} ${u}`;
+  }
+}
+function ur(t, { style: e, vars: i }, n, s) {
+  const o = t.style;
+  let r;
+  for (r in e) o[r] = e[r];
+  s?.applyProjectionStyles(o, n);
+  for (r in i) o.setProperty(r, i[r]);
+}
+function fn(t, e) {
+  return e.max === e.min ? 0 : t / (e.max - e.min) * 100;
+}
+var Rt = { correct: (t, e) => {
+  if (!e.target) return t;
+  if (typeof t == "string") if (y.test(t)) t = parseFloat(t);
+  else return t;
+  return `${fn(t, e.target.x)}% ${fn(t, e.target.y)}%`;
+} }, Il = { correct: (t, { treeScale: e, projectionDelta: i }) => {
+  const n = t, s = G.parse(t);
+  if (s.length > 5) return n;
+  const o = G.createTransformer(t), r = typeof s[0] != "number" ? 1 : 0, a = i.x.scale * e.x, l = i.y.scale * e.y;
+  s[0 + r] /= a, s[1 + r] /= l;
+  const c = V(a, l, 0.5);
+  return typeof s[2 + r] == "number" && (s[2 + r] /= c), typeof s[3 + r] == "number" && (s[3 + r] /= c), o(s);
+} }, Qe = {
+  borderRadius: {
+    ...Rt,
+    applyTo: [...wi]
+  },
+  borderTopLeftRadius: Rt,
+  borderTopRightRadius: Rt,
+  borderBottomLeftRadius: Rt,
+  borderBottomRightRadius: Rt,
+  boxShadow: Il
+};
+function cr(t, { layout: e, layoutId: i }) {
+  return Et.has(t) || t.startsWith("origin") || (e || i !== void 0) && (!!Qe[t] || t === "opacity");
+}
+function Ci(t, e, i) {
+  const n = t.style, s = e?.style, o = {};
+  if (!n) return o;
+  for (const r in n) (F(n[r]) || s && F(s[r]) || cr(r, t) || i?.getValue(r)?.liveStyle !== void 0) && (o[r] = n[r]);
+  return o;
+}
+function Fl(t) {
+  return window.getComputedStyle(t);
+}
+var Ol = class extends sr {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = ur;
+  }
+  readValueFromInstance(t, e) {
+    if (Et.has(e)) return this.projection?.isProjecting ? je(e) : ea(t, e);
+    {
+      const i = Fl(t), n = (ys(e) ? i.getPropertyValue(e) : i[e]) || 0;
+      return typeof n == "string" ? n.trim() : n;
+    }
+  }
+  measureInstanceViewportBox(t, { transformPagePoint: e }) {
+    return lr(t, e);
+  }
+  build(t, e, i) {
+    Mi(t, e, i.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(t, e, i) {
+    return Ci(t, e, i);
+  }
+}, jl = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, Nl = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function Ul(t, e, i = 1, n = 0, s = !0) {
+  t.pathLength = 1;
+  const o = s ? jl : Nl;
+  t[o.offset] = `${-n}`, t[o.array] = `${e} ${i}`;
+}
+var Wl = [
+  "offsetDistance",
+  "offsetPath",
+  "offsetRotate",
+  "offsetAnchor"
+];
+function hr(t, { attrX: e, attrY: i, attrScale: n, pathLength: s, pathSpacing: o = 1, pathOffset: r = 0, ...a }, l, c, u) {
+  if (Mi(t, a, c), l) {
+    t.style.viewBox && (t.attrs.viewBox = t.style.viewBox);
+    return;
+  }
+  t.attrs = t.style, t.style = {};
+  const { attrs: h, style: f } = t;
+  h.transform && (f.transform = h.transform, delete h.transform), (f.transform || h.transformOrigin) && (f.transformOrigin = h.transformOrigin ?? "50% 50%", delete h.transformOrigin), f.transform && (f.transformBox = u?.transformBox ?? "fill-box", delete h.transformBox);
+  for (const p of Wl) h[p] !== void 0 && (f[p] = h[p], delete h[p]);
+  e !== void 0 && (h.x = e), i !== void 0 && (h.y = i), n !== void 0 && (h.scale = n), s !== void 0 && Ul(h, s, o, r, !1);
+}
+var fr = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]), dr = (t) => typeof t == "string" && t.toLowerCase() === "svg";
+function $l(t, e, i, n) {
+  ur(t, e, void 0, n);
+  for (const s in e.attrs) t.setAttribute(fr.has(s) ? s : xi(s), e.attrs[s]);
+}
+function pr(t, e, i) {
+  const n = Ci(t, e, i);
+  for (const s in t) if (F(t[s]) || F(e[s])) {
+    const o = Dt.indexOf(s) !== -1 ? "attr" + s.charAt(0).toUpperCase() + s.substring(1) : s;
+    n[o] = t[s];
+  }
+  return n;
+}
+var Kl = class extends sr {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = L;
+  }
+  getBaseTargetFromProps(t, e) {
+    return t[e];
+  }
+  readValueFromInstance(t, e) {
+    if (Et.has(e)) {
+      const i = Xs(e);
+      return i && i.default || 0;
+    }
+    return e = fr.has(e) ? e : xi(e), t.getAttribute(e);
+  }
+  scrapeMotionValuesFromProps(t, e, i) {
+    return pr(t, e, i);
+  }
+  build(t, e, i) {
+    hr(t, e, this.isSVGTag, i.transformTemplate, i.style);
+  }
+  renderInstance(t, e, i, n) {
+    $l(t, e, i, n);
+  }
+  mount(t) {
+    this.isSVGTag = dr(t.tagName), super.mount(t);
+  }
+}, _l = Vi.length;
+function mr(t) {
+  if (!t) return;
+  if (!t.isControllingVariants) {
+    const i = t.parent ? mr(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (i.initial = t.props.initial), i;
+  }
+  const e = {};
+  for (let i = 0; i < _l; i++) {
+    const n = Vi[i], s = t.props[n];
+    (jt(s) || s === !1) && (e[n] = s);
+  }
+  return e;
+}
+function vr(t, e) {
+  if (!Array.isArray(e)) return !1;
+  const i = e.length;
+  if (i !== t.length) return !1;
+  for (let n = 0; n < i; n++) if (e[n] !== t[n]) return !1;
+  return !0;
+}
+var zl = [...Ai].reverse(), Hl = Ai.length;
+function Gl(t) {
+  return (e) => Promise.all(e.map(({ animation: i, options: n }) => Ka(t, i, n)));
+}
+function Xl(t) {
+  let e = Gl(t), i = dn(), n = !0, s = !1;
+  const o = (c) => (u, h) => {
+    const f = vt(t, h, c === "exit" ? t.presenceContext?.custom : void 0);
+    if (f) {
+      const { transition: p, transitionEnd: d, ...m } = f;
+      u = {
+        ...u,
+        ...m,
+        ...d
+      };
+    }
+    return u;
+  };
+  function r(c) {
+    e = c(t);
+  }
+  function a(c) {
+    const { props: u } = t, h = mr(t.parent) || {}, f = [], p = /* @__PURE__ */ new Set();
+    let d = {}, m = 1 / 0;
+    for (let g = 0; g < Hl; g++) {
+      const T = zl[g], x = i[T], w = u[T] !== void 0 ? u[T] : h[T], P = jt(w), A = T === c ? x.isActive : null;
+      A === !1 && (m = g);
+      let D = w === h[T] && w !== u[T] && P;
+      if (D && (n || s) && t.manuallyAnimateOnMount && (D = !1), x.protectedKeys = { ...d }, !x.isActive && A === null || !w && !x.prevProp || de(w) || typeof w == "boolean") continue;
+      if (T === "exit" && x.isActive && A !== !0) {
+        x.prevResolvedValues && (d = {
+          ...d,
+          ...x.prevResolvedValues
+        });
+        continue;
+      }
+      const S = Yl(x.prevProp, w);
+      let E = S || T === c && x.isActive && !D && P || g > m && P, b = !1;
+      const k = Array.isArray(w) ? w : [w];
+      let N = k.reduce(o(T), {});
+      A === !1 && (N = {});
+      const { prevResolvedValues: at = {} } = x, X = {
+        ...at,
+        ...N
+      }, tt = (B) => {
+        E = !0, p.has(B) && (b = !0, p.delete(B)), x.needsAnimating[B] = !0;
+        const $ = t.getValue(B);
+        $ && ($.liveStyle = !1);
+      };
+      for (const B in X) {
+        const $ = N[B], lt = at[B];
+        if (d.hasOwnProperty(B)) continue;
+        let gt = !1;
+        _e($) && _e(lt) ? gt = !vr($, lt) || S : gt = $ !== lt, gt ? $ != null ? tt(B) : p.add(B) : $ !== void 0 && p.has(B) ? tt(B) : x.protectedKeys[B] = !0;
+      }
+      x.prevProp = w, x.prevResolvedValues = N, x.isActive && (d = {
+        ...d,
+        ...N
+      }), (n || s) && t.blockInitialAnimation && (E = !1);
+      const Y = D && S;
+      E && (!Y || b) && f.push(...k.map((B) => {
+        const $ = { type: T };
+        if (typeof B == "string" && (n || s) && !Y && t.manuallyAnimateOnMount && t.parent) {
+          const { parent: lt } = t, gt = vt(lt, B);
+          if (lt.enteringChildren && gt) {
+            const { delayChildren: jr } = gt.transition || {};
+            $.delay = Ns(lt.enteringChildren, t, jr);
+          }
+        }
+        return {
+          animation: B,
+          options: $
+        };
+      }));
+    }
+    if (p.size) {
+      const g = {};
+      if (typeof u.initial != "boolean") {
+        const T = vt(t, Array.isArray(u.initial) ? u.initial[0] : u.initial);
+        T && T.transition && (g.transition = T.transition);
+      }
+      p.forEach((T) => {
+        const x = t.getBaseTarget(T), w = t.getValue(T);
+        w && (w.liveStyle = !0), g[T] = x ?? null;
+      }), f.push({ animation: g });
+    }
+    let v = !!f.length;
+    return n && (u.initial === !1 || u.initial === u.animate) && !t.manuallyAnimateOnMount && (v = !1), n = !1, s = !1, v ? e(f) : Promise.resolve();
+  }
+  function l(c, u) {
+    if (i[c].isActive === u) return Promise.resolve();
+    t.variantChildren?.forEach((f) => f.animationState?.setActive(c, u)), i[c].isActive = u;
+    const h = a(c);
+    for (const f in i) i[f].protectedKeys = {};
+    return h;
+  }
+  return {
+    animateChanges: a,
+    setActive: l,
+    setAnimateFunction: r,
+    getState: () => i,
+    reset: () => {
+      i = dn(), s = !0;
+    }
+  };
+}
+function Yl(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !vr(e, t) : !1;
+}
+function ut(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function dn() {
+  return {
+    animate: ut(!0),
+    whileInView: ut(),
+    whileHover: ut(),
+    whileTap: ut(),
+    whileDrag: ut(),
+    whileFocus: ut(),
+    exit: ut()
+  };
+}
+function ti(t, e) {
+  t.min = e.min, t.max = e.max;
+}
+function z(t, e) {
+  ti(t.x, e.x), ti(t.y, e.y);
+}
+function pn(t, e) {
+  t.translate = e.translate, t.scale = e.scale, t.originPoint = e.originPoint, t.origin = e.origin;
+}
+var ql = 0.9999, Zl = 1.0001, Jl = -0.01, Ql = 0.01;
+function j(t) {
+  return t.max - t.min;
+}
+function tu(t, e, i) {
+  return Math.abs(t - e) <= i;
+}
+function mn(t, e, i, n = 0.5) {
+  t.origin = n, t.originPoint = V(e.min, e.max, t.origin), t.scale = j(i) / j(e), t.translate = V(i.min, i.max, t.origin) - t.originPoint, (t.scale >= ql && t.scale <= Zl || isNaN(t.scale)) && (t.scale = 1), (t.translate >= Jl && t.translate <= Ql || isNaN(t.translate)) && (t.translate = 0);
+}
+function Bt(t, e, i, n) {
+  mn(t.x, e.x, i.x, n ? n.originX : void 0), mn(t.y, e.y, i.y, n ? n.originY : void 0);
+}
+function vn(t, e, i, n = 0) {
+  t.min = (n ? V(i.min, i.max, n) : i.min) + e.min, t.max = t.min + j(e);
+}
+function eu(t, e, i, n) {
+  vn(t.x, e.x, i.x, n?.x), vn(t.y, e.y, i.y, n?.y);
+}
+function gn(t, e, i, n = 0) {
+  const s = n ? V(i.min, i.max, n) : i.min;
+  t.min = e.min - s, t.max = t.min + j(e);
+}
+function ue(t, e, i, n) {
+  gn(t.x, e.x, i.x, n?.x), gn(t.y, e.y, i.y, n?.y);
+}
+function yn(t, e, i, n, s) {
+  return t -= e, t = le(t, 1 / i, n), s !== void 0 && (t = le(t, 1 / s, n)), t;
+}
+function iu(t, e = 0, i = 1, n = 0.5, s, o = t, r = t) {
+  if (J.test(e) && (e = parseFloat(e), e = V(r.min, r.max, e / 100) - r.min), typeof e != "number") return;
+  let a = V(o.min, o.max, n);
+  t === o && (a -= e), t.min = yn(t.min, e, i, a, s), t.max = yn(t.max, e, i, a, s);
+}
+function Tn(t, e, [i, n, s], o, r) {
+  iu(t, e[i], e[n], e[s], e.scale, o, r);
+}
+var nu = [
+  "x",
+  "scaleX",
+  "originX"
+], su = [
+  "y",
+  "scaleY",
+  "originY"
+];
+function xn(t, e, i, n) {
+  Tn(t.x, e, nu, i ? i.x : void 0, n ? n.x : void 0), Tn(t.y, e, su, i ? i.y : void 0, n ? n.y : void 0);
+}
+function wn(t) {
+  return t.translate === 0 && t.scale === 1;
+}
+function gr(t) {
+  return wn(t.x) && wn(t.y);
+}
+function Pn(t, e) {
+  return t.min === e.min && t.max === e.max;
+}
+function ru(t, e) {
+  return Pn(t.x, e.x) && Pn(t.y, e.y);
+}
+function Sn(t, e) {
+  return Math.round(t.min) === Math.round(e.min) && Math.round(t.max) === Math.round(e.max);
+}
+function yr(t, e) {
+  return Sn(t.x, e.x) && Sn(t.y, e.y);
+}
+function bn(t) {
+  return j(t.x) / j(t.y);
+}
+function An(t, e) {
+  return t.translate === e.translate && t.scale === e.scale && t.originPoint === e.originPoint;
+}
+function q(t) {
+  return [t("x"), t("y")];
+}
+function ou(t, e, i) {
+  let n = "";
+  const s = t.x.translate / e.x, o = t.y.translate / e.y, r = i?.z || 0;
+  if ((s || o || r) && (n = `translate3d(${s}px, ${o}px, ${r}px) `), (e.x !== 1 || e.y !== 1) && (n += `scale(${1 / e.x}, ${1 / e.y}) `), i) {
+    const { transformPerspective: c, rotate: u, pathRotation: h, rotateX: f, rotateY: p, skewX: d, skewY: m } = i;
+    c && (n = `perspective(${c}px) ${n}`), u && (n += `rotate(${u}deg) `), h && (n += `rotate(${h}deg) `), f && (n += `rotateX(${f}deg) `), p && (n += `rotateY(${p}deg) `), d && (n += `skewX(${d}deg) `), m && (n += `skewY(${m}deg) `);
+  }
+  const a = t.x.scale * e.x, l = t.y.scale * e.y;
+  return (a !== 1 || l !== 1) && (n += `scale(${a}, ${l})`), n || "none";
+}
+var au = wi.length, Vn = (t) => typeof t == "string" ? parseFloat(t) : t, Mn = (t) => typeof t == "number" || y.test(t);
+function lu(t, e, i, n, s, o) {
+  s ? (t.opacity = V(0, i.opacity ?? 1, uu(n)), t.opacityExit = V(e.opacity ?? 1, 0, cu(n))) : o && (t.opacity = V(e.opacity ?? 1, i.opacity ?? 1, n));
+  for (let r = 0; r < au; r++) {
+    const a = wi[r];
+    let l = Cn(e, a), c = Cn(i, a);
+    l === void 0 && c === void 0 || (l || (l = 0), c || (c = 0), l === 0 || c === 0 || Mn(l) === Mn(c) ? (t[a] = Math.max(V(Vn(l), Vn(c), n), 0), (J.test(c) || J.test(l)) && (t[a] += "%")) : t[a] = c);
+  }
+  (e.rotate || i.rotate) && (t.rotate = V(e.rotate || 0, i.rotate || 0, n));
+}
+function Cn(t, e) {
+  return t[e] !== void 0 ? t[e] : t.borderRadius;
+}
+var uu = /* @__PURE__ */ Tr(0, 0.5, fs), cu = /* @__PURE__ */ Tr(0.5, 0.95, _);
+function Tr(t, e, i) {
+  return (n) => n < t ? 0 : n > e ? 1 : i(Ft(t, e, n));
+}
+function hu(t, e, i) {
+  const n = F(t) ? t : At(t);
+  return n.start(yi("", n, e, i)), n.animation;
+}
+function Nt(t, e, i, n = { passive: !0 }) {
+  return t.addEventListener(e, i, n), () => t.removeEventListener(e, i, n);
+}
+var fu = (t, e) => t.depth - e.depth, du = class {
+  constructor() {
+    this.children = [], this.isDirty = !1;
+  }
+  add(t) {
+    ri(this.children, t), this.isDirty = !0;
+  }
+  remove(t) {
+    ie(this.children, t), this.isDirty = !0;
+  }
+  forEach(t) {
+    this.isDirty && this.children.sort(fu), this.isDirty = !1, this.children.forEach(t);
+  }
+};
+function pu(t, e) {
+  const i = O.now(), n = ({ timestamp: s }) => {
+    const o = s - i;
+    o >= e && (rt(n), t(o - e));
+  };
+  return M.setup(n, !0), () => rt(n);
+}
+function te(t) {
+  return F(t) ? t.get() : t;
+}
+var mu = class {
+  constructor() {
+    this.members = [];
+  }
+  add(t) {
+    ri(this.members, t);
+    for (let e = this.members.length - 1; e >= 0; e--) {
+      const i = this.members[e];
+      if (i === t || i === this.lead || i === this.prevLead) continue;
+      const n = i.instance;
+      (!n || n.isConnected === !1) && !i.snapshot && (ie(this.members, i), i.unmount());
+    }
+    t.scheduleRender();
+  }
+  remove(t) {
+    if (ie(this.members, t), t === this.prevLead && (this.prevLead = void 0), t === this.lead) {
+      const e = this.members[this.members.length - 1];
+      e && this.promote(e);
+    }
+  }
+  relegate(t) {
+    for (let e = this.members.indexOf(t) - 1; e >= 0; e--) {
+      const i = this.members[e];
+      if (i.isPresent !== !1 && i.instance?.isConnected !== !1)
+        return this.promote(i), !0;
+    }
+    return !1;
+  }
+  promote(t, e) {
+    const i = this.lead;
+    if (t !== i && (this.prevLead = i, this.lead = t, t.show(), i)) {
+      i.updateSnapshot(), t.scheduleRender();
+      const { layoutDependency: n } = i.options, { layoutDependency: s } = t.options;
+      (n === void 0 || n !== s) && (t.resumeFrom = i, e && (i.preserveOpacity = !0), i.snapshot && (t.snapshot = i.snapshot, t.snapshot.latestValues = i.animationValues || i.latestValues), t.root?.isUpdating && (t.isLayoutDirty = !0)), t.options.crossfade === !1 && i.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((t) => {
+      t.options.onExitComplete?.(), t.resumingFrom?.options.onExitComplete?.();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((t) => t.instance && t.scheduleRender(!1));
+  }
+  removeLeadSnapshot() {
+    this.lead?.snapshot && (this.lead.snapshot = void 0);
+  }
+}, ee = {
+  hasAnimatedSinceResize: !0,
+  hasEverUpdated: !1
+}, ht = {
+  nodes: 0,
+  calculatedTargetDeltas: 0,
+  calculatedProjections: 0
+}, Se = [
+  "",
+  "X",
+  "Y",
+  "Z"
+], vu = 1e3, gu = 0;
+function be(t, e, i, n) {
+  const { latestValues: s } = e;
+  s[t] && (i[t] = s[t], e.setStaticValue(t, 0), n && (n[t] = 0));
+}
+function xr(t) {
+  if (t.hasCheckedOptimisedAppear = !0, t.root === t) return;
+  const { visualElement: e } = t.options;
+  if (!e) return;
+  const i = _s(e);
+  if (window.MotionHasOptimisedAnimation(i, "transform")) {
+    const { layout: s, layoutId: o } = t.options;
+    window.MotionCancelOptimisedAnimation(i, "transform", M, !(s || o));
+  }
+  const { parent: n } = t;
+  n && !n.hasCheckedOptimisedAppear && xr(n);
+}
+function wr({ attachResizeListener: t, defaultParent: e, measureScroll: i, checkIsScrollRoot: n, resetTransform: s }) {
+  return class {
+    constructor(r = {}, a = e?.()) {
+      this.id = gu++, this.animationId = 0, this.animationCommitId = 0, this.children = /* @__PURE__ */ new Set(), this.options = {}, this.isTreeAnimating = !1, this.isAnimationBlocked = !1, this.isLayoutDirty = !1, this.isProjectionDirty = !1, this.isSharedProjectionDirty = !1, this.isTransformDirty = !1, this.updateManuallyBlocked = !1, this.updateBlockedByResize = !1, this.isUpdating = !1, this.isSVG = !1, this.needsReset = !1, this.shouldResetTransform = !1, this.hasCheckedOptimisedAppear = !1, this.treeScale = {
+        x: 1,
+        y: 1
+      }, this.eventHandlers = /* @__PURE__ */ new Map(), this.hasTreeAnimated = !1, this.layoutVersion = 0, this.updateScheduled = !1, this.scheduleUpdate = () => this.update(), this.projectionUpdateScheduled = !1, this.checkUpdateFailed = () => {
+        this.isUpdating && (this.isUpdating = !1, this.clearAllSnapshots());
+      }, this.updateProjection = () => {
+        this.projectionUpdateScheduled = !1, yt.value && (ht.nodes = ht.calculatedTargetDeltas = ht.calculatedProjections = 0), this.nodes.forEach(xu), this.nodes.forEach(Vu), this.nodes.forEach(Mu), this.nodes.forEach(wu), yt.addProjectionMetrics && yt.addProjectionMetrics(ht);
+      }, this.resolvedRelativeTargetAt = 0, this.linkedParentVersion = 0, this.hasProjected = !1, this.isVisible = !0, this.animationProgress = 0, this.sharedNodes = /* @__PURE__ */ new Map(), this.latestValues = r, 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 du());
+    }
+    addEventListener(r, a) {
+      return this.eventHandlers.has(r) || this.eventHandlers.set(r, new oi()), this.eventHandlers.get(r).add(a);
+    }
+    notifyListeners(r, ...a) {
+      const l = this.eventHandlers.get(r);
+      l && l.notify(...a);
+    }
+    hasListeners(r) {
+      return this.eventHandlers.has(r);
+    }
+    mount(r) {
+      if (this.instance) return;
+      this.isSVG = bi(r) && !Tl(r), this.instance = r;
+      const { layoutId: a, layout: l, visualElement: c } = this.options;
+      if (c && !c.current && c.mount(r), this.root.nodes.add(this), this.parent && this.parent.children.add(this), this.root.hasTreeAnimated && (l || a) && (this.isLayoutDirty = !0), t) {
+        let u, h = 0;
+        const f = () => this.root.updateBlockedByResize = !1;
+        M.read(() => {
+          h = window.innerWidth;
+        }), t(r, () => {
+          const p = window.innerWidth;
+          p !== h && (h = p, this.root.updateBlockedByResize = !0, u && u(), u = pu(f, 250), ee.hasAnimatedSinceResize && (ee.hasAnimatedSinceResize = !1, this.nodes.forEach(Rn)));
+        });
+      }
+      a && this.root.registerSharedNode(a, this), this.options.animate !== !1 && c && (a || l) && this.addEventListener("didUpdate", ({ delta: u, hasLayoutChanged: h, hasRelativeLayoutChanged: f, layout: p }) => {
+        if (this.isTreeAnimationBlocked()) {
+          this.target = void 0, this.relativeTarget = void 0;
+          return;
+        }
+        const d = this.options.transition || c.getDefaultTransition() || Lu, { onLayoutAnimationStart: m, onLayoutAnimationComplete: v } = c.getProps(), g = !this.targetLayout || !yr(this.targetLayout, p), T = !h && f;
+        if (this.options.layoutRoot || this.resumeFrom || T || h && (g || !this.currentAnimation)) {
+          this.resumeFrom && (this.resumingFrom = this.resumeFrom, this.resumingFrom.resumingFrom = void 0);
+          const x = {
+            ...gi(d, "layout"),
+            onPlay: m,
+            onComplete: v
+          };
+          (c.shouldReduceMotion || this.options.layoutRoot) && (x.delay = 0, x.type = !1), this.startAnimation(x), this.setAnimationOrigin(u, T, x.path);
+        } else
+          h || Rn(this), this.isLead() && this.options.onExitComplete && this.options.onExitComplete();
+        this.targetLayout = p;
+      });
+    }
+    unmount() {
+      this.options.layoutId && this.willUpdate(), this.root.nodes.remove(this);
+      const r = this.getStack();
+      r && r.remove(this), this.parent && this.parent.children.delete(this), this.instance = void 0, this.eventHandlers.clear(), rt(this.updateProjection);
+    }
+    blockUpdate() {
+      this.updateManuallyBlocked = !0;
+    }
+    unblockUpdate() {
+      this.updateManuallyBlocked = !1;
+    }
+    isUpdateBlocked() {
+      return this.updateManuallyBlocked || this.updateBlockedByResize;
+    }
+    isTreeAnimationBlocked() {
+      return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || !1;
+    }
+    startUpdate() {
+      this.isUpdateBlocked() || (this.isUpdating = !0, this.nodes && this.nodes.forEach(Cu), this.animationId++);
+    }
+    getTransformTemplate() {
+      const { visualElement: r } = this.options;
+      return r && r.getProps().transformTemplate;
+    }
+    willUpdate(r = !0) {
+      if (this.root.hasTreeAnimated = !0, this.root.isUpdateBlocked()) {
+        this.options.onExitComplete && this.options.onExitComplete();
+        return;
+      }
+      if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear && xr(this), !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, (typeof h.latestValues.x == "string" || typeof h.latestValues.y == "string") && (h.isLayoutDirty = !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(), r && this.notifyListeners("willUpdate");
+    }
+    update() {
+      if (this.updateScheduled = !1, this.isUpdateBlocked()) {
+        const a = this.updateBlockedByResize;
+        this.unblockUpdate(), this.updateBlockedByResize = !1, this.clearAllSnapshots(), a && this.nodes.forEach(Su), this.nodes.forEach(Dn);
+        return;
+      }
+      if (this.animationId <= this.animationCommitId) {
+        this.nodes.forEach(En);
+        return;
+      }
+      this.animationCommitId = this.animationId, this.isUpdating ? (this.isUpdating = !1, this.nodes.forEach(bu), this.nodes.forEach(Au), this.nodes.forEach(yu), this.nodes.forEach(Tu)) : this.nodes.forEach(En), this.clearAllSnapshots();
+      const r = O.now();
+      I.delta = Q(0, 1e3 / 60, r - I.timestamp), I.timestamp = r, I.isProcessing = !0, ve.update.process(I), ve.preRender.process(I), ve.render.process(I), I.isProcessing = !1;
+    }
+    didUpdate() {
+      this.updateScheduled || (this.updateScheduled = !0, Pi.read(this.scheduleUpdate));
+    }
+    clearAllSnapshots() {
+      this.nodes.forEach(Pu), this.sharedNodes.forEach(Du);
+    }
+    scheduleUpdateProjection() {
+      this.projectionUpdateScheduled || (this.projectionUpdateScheduled = !0, M.preRender(this.updateProjection, !1, !0));
+    }
+    scheduleCheckAfterUnmount() {
+      M.postRender(() => {
+        this.isLayoutDirty ? this.root.didUpdate() : this.root.checkUpdateFailed();
+      });
+    }
+    updateSnapshot() {
+      this.snapshot || !this.instance || (this.snapshot = this.measure(), this.snapshot && !j(this.snapshot.measuredBox.x) && !j(this.snapshot.measuredBox.y) && (this.snapshot = void 0));
+    }
+    updateLayout() {
+      if (!this.instance || (this.updateScroll(), !(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty)) return;
+      if (this.resumeFrom && !this.resumeFrom.instance) for (let l = 0; l < this.path.length; l++) this.path[l].updateScroll();
+      const r = this.layout;
+      this.layout = this.measure(!1), this.layoutVersion++, this.layoutCorrected || (this.layoutCorrected = L()), 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, r ? r.layoutBox : void 0);
+    }
+    updateScroll(r = "measure") {
+      let a = !!(this.options.layoutScroll && this.instance);
+      if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === r && (a = !1), a && this.instance) {
+        const l = n(this.instance);
+        this.scroll = {
+          animationId: this.root.animationId,
+          phase: r,
+          isRoot: l,
+          offset: i(this.instance),
+          wasRoot: this.scroll ? this.scroll.isRoot : l
+        };
+      }
+    }
+    resetTransform() {
+      if (!s) return;
+      const r = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout, a = this.projectionDelta && !gr(this.projectionDelta), l = this.getTransformTemplate(), c = l ? l(this.latestValues, "") : void 0, u = c !== this.prevTransformTemplateValue;
+      r && this.instance && (a || ct(this.latestValues) || u) && (s(this.instance, c), this.shouldResetTransform = !1, this.scheduleRender());
+    }
+    measure(r = !0) {
+      const a = this.measurePageBox();
+      let l = this.removeElementScroll(a);
+      return r && (l = this.removeTransform(l)), ku(l), {
+        animationId: this.root.animationId,
+        measuredBox: a,
+        layoutBox: l,
+        latestValues: {},
+        source: this.id
+      };
+    }
+    measurePageBox() {
+      const { visualElement: r } = this.options;
+      if (!r) return L();
+      const a = r.measureViewportBox();
+      if (!(this.scroll?.wasRoot || this.path.some(Bu))) {
+        const { scroll: l } = this.root;
+        l && (Z(a.x, l.offset.x), Z(a.y, l.offset.y));
+      }
+      return a;
+    }
+    removeElementScroll(r) {
+      const a = L();
+      if (z(a, r), this.scroll?.wasRoot) return a;
+      for (let l = 0; l < this.path.length; l++) {
+        const c = this.path[l], { scroll: u, options: h } = c;
+        c !== this.root && u && h.layoutScroll && (u.wasRoot && z(a, r), Z(a.x, u.offset.x), Z(a.y, u.offset.y));
+      }
+      return a;
+    }
+    applyTransform(r, a = !1, l) {
+      const c = l || L();
+      z(c, r);
+      for (let u = 0; u < this.path.length; u++) {
+        const h = this.path[u];
+        !a && h.options.layoutScroll && h.scroll && h !== h.root && (Z(c.x, -h.scroll.offset.x), Z(c.y, -h.scroll.offset.y)), ct(h.latestValues) && Qt(c, h.latestValues, h.layout?.layoutBox);
+      }
+      return ct(this.latestValues) && Qt(c, this.latestValues, this.layout?.layoutBox), c;
+    }
+    removeTransform(r) {
+      const a = L();
+      z(a, r);
+      for (let l = 0; l < this.path.length; l++) {
+        const c = this.path[l];
+        if (!ct(c.latestValues)) continue;
+        let u;
+        c.instance && (Ze(c.latestValues) && c.updateSnapshot(), u = L(), z(u, c.measurePageBox())), xn(a, c.latestValues, c.snapshot?.layoutBox, u);
+      }
+      return ct(this.latestValues) && xn(a, this.latestValues), a;
+    }
+    setTargetDelta(r) {
+      this.targetDelta = r, this.root.scheduleUpdateProjection(), this.isProjectionDirty = !0;
+    }
+    setOptions(r) {
+      this.options = {
+        ...this.options,
+        ...r,
+        crossfade: r.crossfade !== void 0 ? r.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 !== I.timestamp && this.relativeParent.resolveTargetDelta(!0);
+    }
+    resolveTargetDelta(r = !1) {
+      const a = this.getLead();
+      this.isProjectionDirty || (this.isProjectionDirty = a.isProjectionDirty), this.isTransformDirty || (this.isTransformDirty = a.isTransformDirty), this.isSharedProjectionDirty || (this.isSharedProjectionDirty = a.isSharedProjectionDirty);
+      const l = !!this.resumingFrom || this !== a;
+      if (!(r || l && this.isSharedProjectionDirty || this.isProjectionDirty || this.parent?.isProjectionDirty || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize)) return;
+      const { layout: c, layoutId: u } = this.options;
+      if (!this.layout || !(c || u)) return;
+      this.resolvedRelativeTargetAt = I.timestamp;
+      const h = this.getClosestProjectingParent();
+      h && this.linkedParentVersion !== h.layoutVersion && !h.options.layoutRoot && this.removeRelativeTarget(), !this.targetDelta && !this.relativeTarget && (this.options.layoutAnchor !== !1 && h && h.layout ? this.createRelativeTarget(h, this.layout.layoutBox, h.layout.layoutBox) : this.removeRelativeTarget()), !(!this.relativeTarget && !this.targetDelta) && (this.target || (this.target = L(), this.targetWithTransforms = L()), this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target ? (this.forceRelativeParentToResolveTarget(), eu(this.target, this.relativeTarget, this.relativeParent.target, this.options.layoutAnchor || void 0)) : this.targetDelta ? (this.resumingFrom ? this.applyTransform(this.layout.layoutBox, !1, this.target) : z(this.target, this.layout.layoutBox), ar(this.target, this.targetDelta)) : z(this.target, this.layout.layoutBox), this.attemptToResolveRelativeTarget && (this.attemptToResolveRelativeTarget = !1, this.options.layoutAnchor !== !1 && h && !!h.resumingFrom == !!this.resumingFrom && !h.options.layoutScroll && h.target && this.animationProgress !== 1 ? this.createRelativeTarget(h, this.target, h.target) : this.relativeParent = this.relativeTarget = void 0), yt.value && ht.calculatedTargetDeltas++);
+    }
+    getClosestProjectingParent() {
+      if (!(!this.parent || Ze(this.parent.latestValues) || or(this.parent.latestValues)))
+        return this.parent.isProjecting() ? this.parent : this.parent.getClosestProjectingParent();
+    }
+    isProjecting() {
+      return !!((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
+    }
+    createRelativeTarget(r, a, l) {
+      this.relativeParent = r, this.linkedParentVersion = r.layoutVersion, this.forceRelativeParentToResolveTarget(), this.relativeTarget = L(), this.relativeTargetOrigin = L(), ue(this.relativeTargetOrigin, a, l, this.options.layoutAnchor || void 0), z(this.relativeTarget, this.relativeTargetOrigin);
+    }
+    removeRelativeTarget() {
+      this.relativeParent = this.relativeTarget = void 0;
+    }
+    calcProjection() {
+      const r = this.getLead(), a = !!this.resumingFrom || this !== r;
+      let l = !0;
+      if ((this.isProjectionDirty || this.parent?.isProjectionDirty) && (l = !1), a && (this.isSharedProjectionDirty || this.isTransformDirty) && (l = !1), this.resolvedRelativeTargetAt === I.timestamp && (l = !1), l) return;
+      const { layout: c, layoutId: u } = this.options;
+      if (this.isTreeAnimating = !!(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation), this.isTreeAnimating || (this.targetDelta = this.relativeTarget = void 0), !this.layout || !(c || u)) return;
+      z(this.layoutCorrected, this.layout.layoutBox);
+      const h = this.treeScale.x, f = this.treeScale.y;
+      El(this.layoutCorrected, this.treeScale, this.path, a), r.layout && !r.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1) && (r.target = r.layout.layoutBox, r.targetWithTransforms = L());
+      const { target: p } = r;
+      if (!p) {
+        this.prevProjectionDelta && (this.createProjectionDeltas(), this.scheduleRender());
+        return;
+      }
+      !this.projectionDelta || !this.prevProjectionDelta ? this.createProjectionDeltas() : (pn(this.prevProjectionDelta.x, this.projectionDelta.x), pn(this.prevProjectionDelta.y, this.projectionDelta.y)), Bt(this.projectionDelta, this.layoutCorrected, p, this.latestValues), (this.treeScale.x !== h || this.treeScale.y !== f || !An(this.projectionDelta.x, this.prevProjectionDelta.x) || !An(this.projectionDelta.y, this.prevProjectionDelta.y)) && (this.hasProjected = !0, this.scheduleRender(), this.notifyListeners("projectionUpdate", p)), yt.value && ht.calculatedProjections++;
+    }
+    hide() {
+      this.isVisible = !1;
+    }
+    show() {
+      this.isVisible = !0;
+    }
+    scheduleRender(r = !0) {
+      if (this.options.visualElement?.scheduleRender(), r) {
+        const a = this.getStack();
+        a && a.scheduleRender();
+      }
+      this.resumingFrom && !this.resumingFrom.instance && (this.resumingFrom = void 0);
+    }
+    createProjectionDeltas() {
+      this.prevProjectionDelta = St(), this.projectionDelta = St(), this.projectionDeltaWithTransform = St();
+    }
+    setAnimationOrigin(r, a = !1, l) {
+      const c = this.snapshot, u = c ? c.latestValues : {}, h = { ...this.latestValues }, f = St();
+      (!this.relativeParent || !this.relativeParent.options.layoutRoot) && (this.relativeTarget = this.relativeTargetOrigin = void 0), this.attemptToResolveRelativeTarget = !a;
+      const p = L(), d = (c ? c.source : void 0) !== (this.layout ? this.layout.source : void 0), m = this.getStack(), v = !m || m.members.length <= 1, g = !!(d && !v && this.options.crossfade === !0 && !this.path.some(Ru));
+      this.animationProgress = 0;
+      let T;
+      const x = l?.interpolateProjection(r);
+      this.mixTargetDelta = (w) => {
+        const P = w / 1e3, A = x?.(P);
+        A ? (f.x.translate = A.x, f.x.scale = V(r.x.scale, 1, P), f.x.origin = r.x.origin, f.x.originPoint = r.x.originPoint, f.y.translate = A.y, f.y.scale = V(r.y.scale, 1, P), f.y.origin = r.y.origin, f.y.originPoint = r.y.originPoint) : (Ln(f.x, r.x, P), Ln(f.y, r.y, P)), this.setTargetDelta(f), this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout && (ue(p, this.layout.layoutBox, this.relativeParent.layout.layoutBox, this.options.layoutAnchor || void 0), Eu(this.relativeTarget, this.relativeTargetOrigin, p, P), T && ru(this.relativeTarget, T) && (this.isProjectionDirty = !1), T || (T = L()), z(T, this.relativeTarget)), d && (this.animationValues = h, lu(h, u, this.latestValues, P, g, v)), A && A.rotate !== void 0 && (this.animationValues || (this.animationValues = h), this.animationValues.pathRotation = A.rotate), this.root.scheduleUpdateProjection(), this.scheduleRender(), this.animationProgress = P;
+      }, this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
+    }
+    startAnimation(r) {
+      this.notifyListeners("animationStart"), this.currentAnimation?.stop(), this.resumingFrom?.currentAnimation?.stop(), this.pendingAnimation && (rt(this.pendingAnimation), this.pendingAnimation = void 0), this.pendingAnimation = M.update(() => {
+        ee.hasAnimatedSinceResize = !0, this.motionValue || (this.motionValue = At(0)), this.motionValue.jump(0, !1), this.currentAnimation = hu(this.motionValue, [0, 1e3], {
+          ...r,
+          velocity: 0,
+          isSync: !0,
+          onUpdate: (a) => {
+            this.mixTargetDelta(a), r.onUpdate && r.onUpdate(a);
+          },
+          onComplete: () => {
+            r.onComplete && r.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 r = this.getStack();
+      r && r.exitAnimationComplete(), this.resumingFrom = this.currentAnimation = this.animationValues = void 0, this.notifyListeners("animationComplete");
+    }
+    finishAnimation() {
+      this.currentAnimation && (this.mixTargetDelta && this.mixTargetDelta(vu), this.currentAnimation.stop()), this.completeAnimation();
+    }
+    applyTransformsToTarget() {
+      const r = this.getLead();
+      let { targetWithTransforms: a, target: l, layout: c, latestValues: u } = r;
+      if (!(!a || !l || !c)) {
+        if (this !== r && this.layout && c && Pr(this.options.animationType, this.layout.layoutBox, c.layoutBox)) {
+          l = this.target || L();
+          const h = j(this.layout.layoutBox.x);
+          l.x.min = r.target.x.min, l.x.max = l.x.min + h;
+          const f = j(this.layout.layoutBox.y);
+          l.y.min = r.target.y.min, l.y.max = l.y.min + f;
+        }
+        z(a, l), Qt(a, u), Bt(this.projectionDeltaWithTransform, this.layoutCorrected, a, u);
+      }
+    }
+    registerSharedNode(r, a) {
+      this.sharedNodes.has(r) || this.sharedNodes.set(r, new mu()), this.sharedNodes.get(r).add(a);
+      const l = a.options.initialPromotionConfig;
+      a.promote({
+        transition: l ? l.transition : void 0,
+        preserveFollowOpacity: l && l.shouldPreserveFollowOpacity ? l.shouldPreserveFollowOpacity(a) : void 0
+      });
+    }
+    isLead() {
+      const r = this.getStack();
+      return r ? r.lead === this : !0;
+    }
+    getLead() {
+      const { layoutId: r } = this.options;
+      return r ? this.getStack()?.lead || this : this;
+    }
+    getPrevLead() {
+      const { layoutId: r } = this.options;
+      return r ? this.getStack()?.prevLead : void 0;
+    }
+    getStack() {
+      const { layoutId: r } = this.options;
+      if (r) return this.root.sharedNodes.get(r);
+    }
+    promote({ needsReset: r, transition: a, preserveFollowOpacity: l } = {}) {
+      const c = this.getStack();
+      c && c.promote(this, l), r && (this.projectionDelta = void 0, this.needsReset = !0), a && this.setOptions({ transition: a });
+    }
+    relegate() {
+      const r = this.getStack();
+      return r ? r.relegate(this) : !1;
+    }
+    resetSkewAndRotation() {
+      const { visualElement: r } = this.options;
+      if (!r) return;
+      let a = !1;
+      const { latestValues: l } = r;
+      if ((l.z || l.rotate || l.rotateX || l.rotateY || l.rotateZ || l.skewX || l.skewY) && (a = !0), !a) return;
+      const c = {};
+      l.z && be("z", r, c, this.animationValues);
+      for (let u = 0; u < Se.length; u++)
+        be(`rotate${Se[u]}`, r, c, this.animationValues), be(`skew${Se[u]}`, r, c, this.animationValues);
+      r.render();
+      for (const u in c)
+        r.setStaticValue(u, c[u]), this.animationValues && (this.animationValues[u] = c[u]);
+      r.scheduleRender();
+    }
+    applyProjectionStyles(r, a) {
+      if (!this.instance || this.isSVG) return;
+      if (!this.isVisible) {
+        r.visibility = "hidden";
+        return;
+      }
+      const l = this.getTransformTemplate();
+      if (this.needsReset) {
+        this.needsReset = !1, r.visibility = "", r.opacity = "", r.pointerEvents = te(a?.pointerEvents) || "", r.transform = l ? l(this.latestValues, "") : "none";
+        return;
+      }
+      const c = this.getLead();
+      if (!this.projectionDelta || !this.layout || !c.target) {
+        this.options.layoutId && (r.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1, r.pointerEvents = te(a?.pointerEvents) || ""), this.hasProjected && !ct(this.latestValues) && (r.transform = l ? l({}, "") : "none", this.hasProjected = !1);
+        return;
+      }
+      r.visibility = "";
+      const u = c.animationValues || c.latestValues;
+      this.applyTransformsToTarget();
+      let h = ou(this.projectionDeltaWithTransform, this.treeScale, u);
+      l && (h = l(u, h)), r.transform = h;
+      const { x: f, y: p } = this.projectionDelta;
+      r.transformOrigin = `${f.origin * 100}% ${p.origin * 100}% 0`, c.animationValues ? r.opacity = c === this ? u.opacity ?? this.latestValues.opacity ?? 1 : this.preserveOpacity ? this.latestValues.opacity : u.opacityExit : r.opacity = c === this ? u.opacity !== void 0 ? u.opacity : "" : u.opacityExit !== void 0 ? u.opacityExit : 0;
+      for (const d in Qe) {
+        if (u[d] === void 0) continue;
+        const { correct: m, applyTo: v, isCSSVariable: g } = Qe[d], T = h === "none" ? u[d] : m(u[d], c);
+        if (v) {
+          const x = v.length;
+          for (let w = 0; w < x; w++) r[v[w]] = T;
+        } else g ? this.options.visualElement.renderState.vars[d] = T : r[d] = T;
+      }
+      this.options.layoutId && (r.pointerEvents = c === this ? te(a?.pointerEvents) || "" : "none");
+    }
+    clearSnapshot() {
+      this.resumeFrom = this.snapshot = void 0;
+    }
+    resetTree() {
+      this.root.nodes.forEach((r) => r.currentAnimation?.stop()), this.root.nodes.forEach(Dn), this.root.sharedNodes.clear();
+    }
+  };
+}
+function yu(t) {
+  t.updateLayout();
+}
+function Tu(t) {
+  const e = t.resumeFrom?.snapshot || t.snapshot;
+  if (t.isLead() && t.layout && e && t.hasListeners("didUpdate")) {
+    const { layoutBox: i, measuredBox: n } = t.layout, { animationType: s } = t.options, o = e.source !== t.layout.source;
+    if (s === "size") q((u) => {
+      const h = o ? e.measuredBox[u] : e.layoutBox[u], f = j(h);
+      h.min = i[u].min, h.max = h.min + f;
+    });
+    else if (s === "x" || s === "y") {
+      const u = s === "x" ? "y" : "x";
+      ti(o ? e.measuredBox[u] : e.layoutBox[u], i[u]);
+    } else Pr(s, e.layoutBox, i) && q((u) => {
+      const h = o ? e.measuredBox[u] : e.layoutBox[u], f = j(i[u]);
+      h.max = h.min + f, t.relativeTarget && !t.currentAnimation && (t.isProjectionDirty = !0, t.relativeTarget[u].max = t.relativeTarget[u].min + f);
+    });
+    const r = St();
+    Bt(r, i, e.layoutBox);
+    const a = St();
+    o ? Bt(a, t.applyTransform(n, !0), e.measuredBox) : Bt(a, i, e.layoutBox);
+    const l = !gr(r);
+    let c = !1;
+    if (!t.resumeFrom) {
+      const u = t.getClosestProjectingParent();
+      if (u && !u.resumeFrom) {
+        const { snapshot: h, layout: f } = u;
+        if (h && f) {
+          const p = t.options.layoutAnchor || void 0, d = L();
+          ue(d, e.layoutBox, h.layoutBox, p);
+          const m = L();
+          ue(m, i, f.layoutBox, p), yr(d, m) || (c = !0), u.options.layoutRoot && (t.relativeTarget = m, t.relativeTargetOrigin = d, t.relativeParent = u);
+        }
+      }
+    }
+    t.notifyListeners("didUpdate", {
+      layout: i,
+      snapshot: e,
+      delta: a,
+      layoutDelta: r,
+      hasLayoutChanged: l,
+      hasRelativeLayoutChanged: c
+    });
+  } else if (t.isLead()) {
+    const { onExitComplete: i } = t.options;
+    i && i();
+  }
+  t.options.transition = void 0;
+}
+function xu(t) {
+  yt.value && ht.nodes++, 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 wu(t) {
+  t.isProjectionDirty = t.isSharedProjectionDirty = t.isTransformDirty = !1;
+}
+function Pu(t) {
+  t.clearSnapshot();
+}
+function Dn(t) {
+  t.clearMeasurements();
+}
+function Su(t) {
+  t.isLayoutDirty = !0, t.updateLayout();
+}
+function En(t) {
+  t.isLayoutDirty = !1;
+}
+function bu(t) {
+  t.isAnimationBlocked && t.layout && !t.isLayoutDirty && (t.snapshot = t.layout, t.isLayoutDirty = !0);
+}
+function Au(t) {
+  const { visualElement: e } = t.options;
+  e && e.getProps().onBeforeLayoutMeasure && e.notify("BeforeLayoutMeasure"), t.resetTransform();
+}
+function Rn(t) {
+  t.finishAnimation(), t.targetDelta = t.relativeTarget = t.target = void 0, t.isProjectionDirty = !0;
+}
+function Vu(t) {
+  t.resolveTargetDelta();
+}
+function Mu(t) {
+  t.calcProjection();
+}
+function Cu(t) {
+  t.resetSkewAndRotation();
+}
+function Du(t) {
+  t.removeLeadSnapshot();
+}
+function Ln(t, e, i) {
+  t.translate = V(e.translate, 0, i), t.scale = V(e.scale, 1, i), t.origin = e.origin, t.originPoint = e.originPoint;
+}
+function kn(t, e, i, n) {
+  t.min = V(e.min, i.min, n), t.max = V(e.max, i.max, n);
+}
+function Eu(t, e, i, n) {
+  kn(t.x, e.x, i.x, n), kn(t.y, e.y, i.y, n);
+}
+function Ru(t) {
+  return t.animationValues && t.animationValues.opacityExit !== void 0;
+}
+var Lu = {
+  duration: 0.45,
+  ease: [
+    0.4,
+    0,
+    0.1,
+    1
+  ]
+}, Bn = (t) => typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(t), In = Bn("applewebkit/") && !Bn("chrome/") ? Math.round : _;
+function Fn(t) {
+  t.min = In(t.min), t.max = In(t.max);
+}
+function ku(t) {
+  Fn(t.x), Fn(t.y);
+}
+function Pr(t, e, i) {
+  return t === "position" || t === "preserve-aspect" && !tu(bn(e), bn(i), 0.2);
+}
+function Bu(t) {
+  return t !== t.root && t.scroll?.wasRoot;
+}
+var Iu = wr({
+  attachResizeListener: (t, e) => Nt(t, "resize", e),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body?.scrollLeft || 0,
+    y: document.documentElement.scrollTop || document.body?.scrollTop || 0
+  }),
+  checkIsScrollRoot: () => !0
+}), Ae = { current: void 0 }, Sr = wr({
+  measureScroll: (t) => ({
+    x: t.scrollLeft,
+    y: t.scrollTop
+  }),
+  defaultParent: () => {
+    if (!Ae.current) {
+      const t = new Iu({});
+      t.mount(window), t.setOptions({ layoutScroll: !0 }), Ae.current = t;
+    }
+    return Ae.current;
+  },
+  resetTransform: (t, e) => {
+    t.style.transform = e !== void 0 ? e : "none";
+  },
+  checkIsScrollRoot: (t) => window.getComputedStyle(t).position === "fixed"
+}), br = Vt({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+});
+function Fu(t = !0) {
+  const e = U(si);
+  if (e === null) return [!0, null];
+  const { isPresent: i, onExitComplete: n, register: s } = e, o = zr();
+  ni(() => {
+    if (t) return s(o);
+  }, [t]);
+  const r = Zn(() => t && n && n(o), [
+    o,
+    n,
+    t
+  ]);
+  return !i && n ? [!1, r] : [!0];
+}
+var Ar = Vt({ strict: !1 }), On = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: [
+    "whileHover",
+    "onHoverStart",
+    "onHoverEnd"
+  ],
+  tap: [
+    "whileTap",
+    "onTap",
+    "onTapStart",
+    "onTapCancel"
+  ],
+  pan: [
+    "onPan",
+    "onPanStart",
+    "onPanSessionStart",
+    "onPanEnd"
+  ],
+  inView: [
+    "whileInView",
+    "onViewportEnter",
+    "onViewportLeave"
+  ],
+  layout: ["layout", "layoutId"]
+}, jn = !1;
+function Ou() {
+  if (jn) return;
+  const t = {};
+  for (const e in On) t[e] = { isEnabled: (i) => On[e].some((n) => !!i[n]) };
+  nr(t), jn = !0;
+}
+function Vr() {
+  return Ou(), Vl();
+}
+function ju(t) {
+  const e = Vr();
+  for (const i in t) e[i] = {
+    ...e[i],
+    ...t[i]
+  };
+  nr(e);
+}
+var Nu = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "propagate",
+  "ignoreStrict",
+  "viewport"
+]);
+function ce(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || Nu.has(t);
+}
+var Uu = /* @__PURE__ */ Wr({ default: () => Mr }), Mr, Wu = Ur((() => {
+  throw Mr = {}, new Error('Could not resolve "@emotion/is-prop-valid" imported by "framer-motion". Is it installed?');
+})), Cr = (t) => !ce(t);
+function $u(t) {
+  typeof t == "function" && (Cr = (e) => e.startsWith("on") ? !ce(e) : t(e));
+}
+try {
+  $u((Wu(), Nr(Uu)).default);
+} catch {
+}
+function Ku(t, e, i) {
+  const n = {};
+  for (const s in t)
+    s === "values" && typeof t.values == "object" || F(t[s]) || (Cr(s) || i === !0 && ce(s) || !e && !ce(s) || t.draggable && s.startsWith("onDrag")) && (n[s] = t[s]);
+  return n;
+}
+var me = /* @__PURE__ */ Vt({});
+function _u(t, e) {
+  if (pe(t)) {
+    const { initial: i, animate: n } = t;
+    return {
+      initial: i === !1 || jt(i) ? i : void 0,
+      animate: jt(n) ? n : void 0
+    };
+  }
+  return t.inherit !== !1 ? e : {};
+}
+function zu(t) {
+  const { initial: e, animate: i } = _u(t, U(me));
+  return he(() => ({
+    initial: e,
+    animate: i
+  }), [Nn(e), Nn(i)]);
+}
+function Nn(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+var Di = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+function Dr(t, e, i) {
+  for (const n in e) !F(e[n]) && !cr(n, i) && (t[n] = e[n]);
+}
+function Hu({ transformTemplate: t }, e) {
+  return he(() => {
+    const i = Di();
+    return Mi(i, e, t), Object.assign({}, i.vars, i.style);
+  }, [e]);
+}
+function Gu(t, e) {
+  const i = t.style || {}, n = {};
+  return Dr(n, i, t), Object.assign(n, Hu(t, e)), n;
+}
+function Xu(t, e) {
+  const i = {}, n = Gu(t, e);
+  return t.drag && t.dragListener !== !1 && (i.draggable = !1, n.userSelect = n.WebkitUserSelect = n.WebkitTouchCallout = "none", n.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (i.tabIndex = 0), i.style = n, i;
+}
+var Er = () => ({
+  ...Di(),
+  attrs: {}
+});
+function Yu(t, e, i, n) {
+  const s = he(() => {
+    const o = Er();
+    return hr(o, e, dr(n), t.transformTemplate, t.style), {
+      ...o.attrs,
+      style: { ...o.style }
+    };
+  }, [e]);
+  if (t.style) {
+    const o = {};
+    Dr(o, t.style, t), s.style = {
+      ...o,
+      ...s.style
+    };
+  }
+  return s;
+}
+var qu = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+function Ei(t) {
+  return typeof t != "string" || t.includes("-") ? !1 : !!(qu.indexOf(t) > -1 || /[A-Z]/u.test(t));
+}
+function Zu(t, e, i, { latestValues: n }, s, o = !1, r) {
+  const a = (r ?? Ei(t) ? Yu : Xu)(e, n, s, t), l = Ku(e, typeof t == "string", o), c = t !== qn ? {
+    ...l,
+    ...a,
+    ref: i
+  } : {}, { children: u } = e, h = he(() => F(u) ? u.get() : u, [u]);
+  return Kr(t, {
+    ...c,
+    children: h
+  });
+}
+function Ju({ scrapeMotionValuesFromProps: t, createRenderState: e }, i, n, s) {
+  return {
+    latestValues: Qu(i, n, s, t),
+    renderState: e()
+  };
+}
+function Qu(t, e, i, n) {
+  const s = {}, o = n(t, {});
+  for (const f in o) s[f] = te(o[f]);
+  let { initial: r, animate: a } = t;
+  const l = pe(t), c = er(t);
+  e && c && !l && t.inherit !== !1 && (r === void 0 && (r = e.initial), a === void 0 && (a = e.animate));
+  let u = i ? i.initial === !1 : !1;
+  u = u || r === !1;
+  const h = u ? a : r;
+  if (h && typeof h != "boolean" && !de(h)) {
+    const f = Array.isArray(h) ? h : [h];
+    for (let p = 0; p < f.length; p++) {
+      const d = Ti(t, f[p]);
+      if (d) {
+        const { transitionEnd: m, transition: v, ...g } = d;
+        for (const T in g) {
+          let x = g[T];
+          if (Array.isArray(x)) {
+            const w = u ? x.length - 1 : 0;
+            x = x[w];
+          }
+          x !== null && (s[T] = x);
+        }
+        for (const T in m) s[T] = m[T];
+      }
+    }
+  }
+  return s;
+}
+var Rr = (t) => (e, i) => {
+  const n = U(me), s = U(si), o = () => Ju(t, e, n, s);
+  return i ? o() : Xr(o);
+}, tc = /* @__PURE__ */ Rr({
+  scrapeMotionValuesFromProps: Ci,
+  createRenderState: Di
+}), ec = /* @__PURE__ */ Rr({
+  scrapeMotionValuesFromProps: pr,
+  createRenderState: Er
+}), ic = /* @__PURE__ */ Symbol.for("motionComponentSymbol");
+function nc(t, e, i) {
+  const n = ft(i);
+  Jn(() => {
+    n.current = i;
+  });
+  const s = ft(null);
+  return Zn((o) => {
+    o && t.onMount?.(o), e && (o ? e.mount(o) : e.unmount());
+    const r = n.current;
+    if (typeof r == "function") if (o) {
+      const a = r(o);
+      typeof a == "function" && (s.current = a);
+    } else s.current ? (s.current(), s.current = null) : r(o);
+    else r && (r.current = o);
+  }, [e]);
+}
+var Lr = Vt({});
+function Tt(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+function sc(t, e, i, n, s, o) {
+  const { visualElement: r } = U(me), a = U(Ar), l = U(si), c = U(br), u = c.reducedMotion, h = c.skipAnimations, f = ft(null), p = ft(!1);
+  n = n || a.renderer, !f.current && n && (f.current = n(t, {
+    visualState: e,
+    parent: r,
+    props: i,
+    presenceContext: l,
+    blockInitialAnimation: l ? l.initial === !1 : !1,
+    reducedMotionConfig: u,
+    skipAnimations: h,
+    isSVG: o
+  }), p.current && f.current && (f.current.manuallyAnimateOnMount = !0));
+  const d = f.current, m = U(Lr);
+  d && !d.projection && s && (d.type === "html" || d.type === "svg") && rc(f.current, i, s, m);
+  const v = ft(!1);
+  Jn(() => {
+    d && v.current && d.update(i, l);
+  });
+  const g = i[Ks], T = ft(!!g && typeof window < "u" && !window.MotionHandoffIsComplete?.(g) && window.MotionHasOptimisedAnimation?.(g));
+  return qr(() => {
+    p.current = !0, d && (v.current = !0, window.MotionIsMounted = !0, d.updateFeatures(), d.scheduleRenderMicrotask(), T.current && d.animationState && d.animationState.animateChanges());
+  }), ni(() => {
+    d && (!T.current && d.animationState && d.animationState.animateChanges(), T.current && (queueMicrotask(() => {
+      window.MotionHandoffMarkAsComplete?.(g);
+    }), T.current = !1), d.enteringChildren = void 0);
+  }), d;
+}
+function rc(t, e, i, n) {
+  const { layoutId: s, layout: o, drag: r, dragConstraints: a, layoutScroll: l, layoutRoot: c, layoutAnchor: u, layoutCrossfade: h } = e;
+  t.projection = new i(t.latestValues, e["data-framer-portal-id"] ? void 0 : kr(t.parent)), t.projection.setOptions({
+    layoutId: s,
+    layout: o,
+    alwaysMeasureLayout: !!r || a && Tt(a),
+    visualElement: t,
+    animationType: typeof o == "string" ? o : "both",
+    initialPromotionConfig: n,
+    crossfade: h,
+    layoutScroll: l,
+    layoutRoot: c,
+    layoutAnchor: u
+  });
+}
+function kr(t) {
+  if (t)
+    return t.options.allowProjection !== !1 ? t.projection : kr(t.parent);
+}
+function Ve(t, { forwardMotionProps: e = !1, type: i } = {}, n, s) {
+  n && ju(n);
+  const o = i ? i === "svg" : Ei(t), r = o ? ec : tc;
+  function a(c, u) {
+    let h;
+    const f = {
+      ...U(br),
+      ...c,
+      layoutId: oc(c)
+    }, { isStatic: p } = f, d = zu(c), m = r(c, p);
+    if (!p && typeof window < "u") {
+      ac(f, n);
+      const v = lc(f);
+      h = v.MeasureLayout, d.visualElement = sc(t, m, f, s, v.ProjectionNode, o);
+    }
+    return Gr(me.Provider, {
+      value: d,
+      children: [h && d.visualElement ? Qn(h, {
+        visualElement: d.visualElement,
+        ...f
+      }) : null, Zu(t, c, nc(m, d.visualElement, u), m, p, e, o)]
+    });
+  }
+  a.displayName = `motion.${typeof t == "string" ? t : `create(${t.displayName ?? t.name ?? ""})`}`;
+  const l = _r(a);
+  return l[ic] = t, l;
+}
+function oc({ layoutId: t }) {
+  const e = U(ts).id;
+  return e && t !== void 0 ? e + "-" + t : t;
+}
+function ac(t, e) {
+  const i = U(Ar).strict;
+  if (process.env.NODE_ENV !== "production" && e && i) {
+    const n = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? Mt(!1, n, "lazy-strict-mode") : it(!1, n, "lazy-strict-mode");
+  }
+}
+function lc(t) {
+  const { drag: e, layout: i } = Vr();
+  if (!e && !i) return {};
+  const n = {
+    ...e,
+    ...i
+  };
+  return {
+    MeasureLayout: e?.isEnabled(t) || i?.isEnabled(t) ? n.MeasureLayout : void 0,
+    ProjectionNode: n.ProjectionNode
+  };
+}
+function uc(t, e) {
+  if (typeof Proxy > "u") return Ve;
+  const i = /* @__PURE__ */ new Map(), n = (o, r) => Ve(o, r, t, e), s = (o, r) => (process.env.NODE_ENV !== "production" && ai(!1, "motion() is deprecated. Use motion.create() instead."), n(o, r));
+  return new Proxy(s, { get: (o, r) => r === "create" ? n : (i.has(r) || i.set(r, Ve(r, void 0, t, e)), i.get(r)) });
+}
+var cc = (t, e) => e.isSVG ?? Ei(t) ? new Kl(e) : new Ol(e, { allowProjection: t !== qn }), hc = class extends ot {
+  constructor(t) {
+    super(t), t.animationState || (t.animationState = Xl(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    de(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: e } = this.node.prevProps || {};
+    t !== e && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    this.node.animationState.reset(), this.unmountControls?.();
+  }
+}, fc = 0, dc = class extends ot {
+  constructor() {
+    super(...arguments), this.id = fc++, this.isExitComplete = !1;
+  }
+  update() {
+    if (!this.node.presenceContext) return;
+    const { isPresent: t, onExitComplete: e } = this.node.presenceContext, { isPresent: i } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === i) return;
+    if (t && i === !1) {
+      if (this.isExitComplete) {
+        const { initial: s, custom: o } = this.node.getProps();
+        if (typeof s == "string" || typeof s == "object" && s !== null && !Array.isArray(s)) {
+          const r = vt(this.node, s, o);
+          if (r) {
+            const { transition: a, transitionEnd: l, ...c } = r;
+            for (const u in c) this.node.getValue(u)?.jump(c[u]);
+          }
+        }
+        this.node.animationState.reset(), this.node.animationState.animateChanges();
+      } else this.node.animationState.setActive("exit", !1);
+      this.isExitComplete = !1;
+      return;
+    }
+    const n = this.node.animationState.setActive("exit", !t);
+    e && !t && n.then(() => {
+      this.isExitComplete = !0, e(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: e } = this.node.presenceContext || {};
+    e && e(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}, pc = {
+  animation: { Feature: hc },
+  exit: { Feature: dc }
+};
+function Kt(t) {
+  return { point: {
+    x: t.pageX,
+    y: t.pageY
+  } };
+}
+var mc = (t) => (e) => Si(e) && t(e, Kt(e));
+function It(t, e, i, n) {
+  return Nt(t, e, mc(i), n);
+}
+var Br = ({ current: t }) => t ? t.ownerDocument.defaultView : null, Un = (t, e) => Math.abs(t - e);
+function vc(t, e) {
+  const i = Un(t.x, e.x), n = Un(t.y, e.y);
+  return Math.sqrt(i ** 2 + n ** 2);
+}
+var Wn = /* @__PURE__ */ new Set(["auto", "scroll"]), Ir = class {
+  constructor(t, e, { transformPagePoint: i, contextWindow: n = window, dragSnapToOrigin: s = !1, distanceThreshold: o = 3, element: r } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.lastRawMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = /* @__PURE__ */ new Map(), this.removeScrollListeners = null, this.onElementScroll = (f) => {
+      this.handleScroll(f.target);
+    }, this.onWindowScroll = () => {
+      this.handleScroll(window);
+    }, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+      this.lastRawMoveEventInfo && (this.lastMoveEventInfo = Ht(this.lastRawMoveEventInfo, this.transformPagePoint));
+      const f = Me(this.lastMoveEventInfo, this.history), p = this.startEvent !== null, d = vc(f.offset, {
+        x: 0,
+        y: 0
+      }) >= this.distanceThreshold;
+      if (!p && !d) return;
+      const { point: m } = f, { timestamp: v } = I;
+      this.history.push({
+        ...m,
+        timestamp: v
+      });
+      const { onStart: g, onMove: T } = this.handlers;
+      p || (g && g(this.lastMoveEvent, f), this.startEvent = this.lastMoveEvent), T && T(this.lastMoveEvent, f);
+    }, this.handlePointerMove = (f, p) => {
+      this.lastMoveEvent = f, this.lastRawMoveEventInfo = p, this.lastMoveEventInfo = Ht(p, this.transformPagePoint), M.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (f, p) => {
+      this.end();
+      const { onEnd: d, onSessionEnd: m, resumeAnimation: v } = this.handlers;
+      if ((this.dragSnapToOrigin || !this.startEvent) && v && v(), !(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+      const g = Me(f.type === "pointercancel" ? this.lastMoveEventInfo : Ht(p, this.transformPagePoint), this.history);
+      this.startEvent && d && d(f, g), m && m(f, g);
+    }, !Si(t)) return;
+    this.dragSnapToOrigin = s, this.handlers = e, this.transformPagePoint = i, this.distanceThreshold = o, this.contextWindow = n || window;
+    const a = Ht(Kt(t), this.transformPagePoint), { point: l } = a, { timestamp: c } = I;
+    this.history = [{
+      ...l,
+      timestamp: c
+    }];
+    const { onSessionStart: u } = e;
+    u && u(t, Me(a, this.history));
+    const h = {
+      passive: !0,
+      capture: !0
+    };
+    this.removeListeners = Ut(It(this.contextWindow, "pointermove", this.handlePointerMove, h), It(this.contextWindow, "pointerup", this.handlePointerUp, h), It(this.contextWindow, "pointercancel", this.handlePointerUp, h)), r && this.startScrollTracking(r);
+  }
+  startScrollTracking(t) {
+    let e = t.parentElement;
+    for (; e; ) {
+      const i = getComputedStyle(e);
+      (Wn.has(i.overflowX) || Wn.has(i.overflowY)) && this.scrollPositions.set(e, {
+        x: e.scrollLeft,
+        y: e.scrollTop
+      }), e = e.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    }), window.addEventListener("scroll", this.onElementScroll, { capture: !0 }), window.addEventListener("scroll", this.onWindowScroll), this.removeScrollListeners = () => {
+      window.removeEventListener("scroll", this.onElementScroll, { capture: !0 }), window.removeEventListener("scroll", this.onWindowScroll);
+    };
+  }
+  handleScroll(t) {
+    const e = this.scrollPositions.get(t);
+    if (!e) return;
+    const i = t === window, n = i ? {
+      x: window.scrollX,
+      y: window.scrollY
+    } : {
+      x: t.scrollLeft,
+      y: t.scrollTop
+    }, s = {
+      x: n.x - e.x,
+      y: n.y - e.y
+    };
+    s.x === 0 && s.y === 0 || (i ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += s.x, this.lastMoveEventInfo.point.y += s.y) : this.history.length > 0 && (this.history[0].x -= s.x, this.history[0].y -= s.y), this.scrollPositions.set(t, n), M.update(this.updatePoint, !0));
+  }
+  updateHandlers(t) {
+    this.handlers = t;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), this.removeScrollListeners && this.removeScrollListeners(), this.scrollPositions.clear(), rt(this.updatePoint);
+  }
+};
+function Ht(t, e) {
+  return e ? { point: e(t.point) } : t;
+}
+function $n(t, e) {
+  return {
+    x: t.x - e.x,
+    y: t.y - e.y
+  };
+}
+function Me({ point: t }, e) {
+  return {
+    point: t,
+    delta: $n(t, Fr(e)),
+    offset: $n(t, gc(e)),
+    velocity: yc(e, 0.1)
+  };
+}
+function gc(t) {
+  return t[0];
+}
+function Fr(t) {
+  return t[t.length - 1];
+}
+function yc(t, e) {
+  if (t.length < 2) return {
+    x: 0,
+    y: 0
+  };
+  let i = t.length - 1, n = null;
+  const s = Fr(t);
+  for (; i >= 0 && (n = t[i], !(s.timestamp - n.timestamp > W(e))); )
+    i--;
+  if (!n) return {
+    x: 0,
+    y: 0
+  };
+  n === t[0] && t.length > 2 && s.timestamp - n.timestamp > W(e) * 2 && (n = t[1]);
+  const o = K(s.timestamp - n.timestamp);
+  if (o === 0) return {
+    x: 0,
+    y: 0
+  };
+  const r = {
+    x: (s.x - n.x) / o,
+    y: (s.y - n.y) / o
+  };
+  return r.x === 1 / 0 && (r.x = 0), r.y === 1 / 0 && (r.y = 0), r;
+}
+function Tc(t, { min: e, max: i }, n) {
+  return e !== void 0 && t < e ? t = n ? V(e, t, n.min) : Math.max(t, e) : i !== void 0 && t > i && (t = n ? V(i, t, n.max) : Math.min(t, i)), t;
+}
+function Kn(t, e, i) {
+  return {
+    min: e !== void 0 ? t.min + e : void 0,
+    max: i !== void 0 ? t.max + i - (t.max - t.min) : void 0
+  };
+}
+function xc(t, { top: e, left: i, bottom: n, right: s }) {
+  return {
+    x: Kn(t.x, i, s),
+    y: Kn(t.y, e, n)
+  };
+}
+function _n(t, e) {
+  let i = e.min - t.min, n = e.max - t.max;
+  return e.max - e.min < t.max - t.min && ([i, n] = [n, i]), {
+    min: i,
+    max: n
+  };
+}
+function wc(t, e) {
+  return {
+    x: _n(t.x, e.x),
+    y: _n(t.y, e.y)
+  };
+}
+function Pc(t, e) {
+  let i = 0.5;
+  const n = j(t), s = j(e);
+  return s > n ? i = Ft(e.min, e.max - n, t.min) : n > s && (i = Ft(t.min, t.max - s, e.min)), Q(0, 1, i);
+}
+function Sc(t, e) {
+  const i = {};
+  return e.min !== void 0 && (i.min = e.min - t.min), e.max !== void 0 && (i.max = e.max - t.min), i;
+}
+var ei = 0.35;
+function bc(t = ei) {
+  return t === !1 ? t = 0 : t === !0 && (t = ei), {
+    x: zn(t, "left", "right"),
+    y: zn(t, "top", "bottom")
+  };
+}
+function zn(t, e, i) {
+  return {
+    min: Hn(t, e),
+    max: Hn(t, i)
+  };
+}
+function Hn(t, e) {
+  return typeof t == "number" ? t : t[e] || 0;
+}
+var Ac = /* @__PURE__ */ new WeakMap(), Vc = class {
+  constructor(t) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = {
+      x: 0,
+      y: 0
+    }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = L(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = t;
+  }
+  start(t, { snapToCursor: e = !1, distanceThreshold: i } = {}) {
+    const { presenceContext: n } = this.visualElement;
+    if (n && n.isPresent === !1) return;
+    const s = (u) => {
+      e && this.snapToCursor(Kt(u).point), this.stopAnimation();
+    }, o = (u, h) => {
+      const { drag: f, dragPropagation: p, onDragStart: d } = this.getProps();
+      if (f && !p && (this.openDragLock && this.openDragLock(), this.openDragLock = il(f), !this.openDragLock))
+        return;
+      this.latestPointerEvent = u, this.latestPanInfo = h, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), q((v) => {
+        let g = this.getAxisMotionValue(v).get() || 0;
+        if (J.test(g)) {
+          const { projection: T } = this.visualElement;
+          if (T && T.layout) {
+            const x = T.layout.layoutBox[v];
+            x && (g = j(x) * (parseFloat(g) / 100));
+          }
+        }
+        this.originPoint[v] = g;
+      }), d && M.update(() => d(u, h), !1, !0), ze(this.visualElement, "transform");
+      const { animationState: m } = this.visualElement;
+      m && m.setActive("whileDrag", !0);
+    }, r = (u, h) => {
+      this.latestPointerEvent = u, this.latestPanInfo = h;
+      const { dragPropagation: f, dragDirectionLock: p, onDirectionLock: d, onDrag: m } = this.getProps();
+      if (!f && !this.openDragLock) return;
+      const { offset: v } = h;
+      if (p && this.currentDirection === null) {
+        this.currentDirection = Cc(v), this.currentDirection !== null && d && d(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", h.point, v), this.updateAxis("y", h.point, v), this.visualElement.render(), m && M.update(() => m(u, h), !1, !0);
+    }, a = (u, h) => {
+      this.latestPointerEvent = u, this.latestPanInfo = h, this.stop(u, h), this.latestPointerEvent = null, this.latestPanInfo = null;
+    }, l = () => {
+      const { dragSnapToOrigin: u } = this.getProps();
+      (u || this.constraints) && this.startAnimation({
+        x: 0,
+        y: 0
+      });
+    }, { dragSnapToOrigin: c } = this.getProps();
+    this.panSession = new Ir(t, {
+      onSessionStart: s,
+      onStart: o,
+      onMove: r,
+      onSessionEnd: a,
+      resumeAnimation: l
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: c,
+      distanceThreshold: i,
+      contextWindow: Br(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  stop(t, e) {
+    const i = t || this.latestPointerEvent, n = e || this.latestPanInfo, s = this.isDragging;
+    if (this.cancel(), !s || !n || !i) return;
+    const { velocity: o } = n;
+    this.startAnimation(o);
+    const { onDragEnd: r } = this.getProps();
+    r && M.postRender(() => r(i, n));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: e } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.endPanSession();
+    const { dragPropagation: i } = this.getProps();
+    !i && this.openDragLock && (this.openDragLock(), this.openDragLock = null), e && e.setActive("whileDrag", !1);
+  }
+  endPanSession() {
+    this.panSession && this.panSession.end(), this.panSession = void 0;
+  }
+  updateAxis(t, e, i) {
+    const { drag: n } = this.getProps();
+    if (!i || !Gt(t, n, this.currentDirection)) return;
+    const s = this.getAxisMotionValue(t);
+    let o = this.originPoint[t] + i[t];
+    this.constraints && this.constraints[t] && (o = Tc(o, this.constraints[t], this.elastic[t])), s.set(o);
+  }
+  resolveConstraints() {
+    const { dragConstraints: t, dragElastic: e } = this.getProps(), i = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection?.layout, n = this.constraints;
+    t && Tt(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && i ? this.constraints = xc(i.layoutBox, t) : this.constraints = !1, this.elastic = bc(e), n !== this.constraints && !Tt(t) && i && this.constraints && !this.hasMutatedConstraints && q((s) => {
+      this.constraints !== !1 && this.getAxisMotionValue(s) && (this.constraints[s] = Sc(i.layoutBox[s], this.constraints[s]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: e } = this.getProps();
+    if (!t || !Tt(t)) return !1;
+    const i = t.current;
+    it(i !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection: n } = this.visualElement;
+    if (!n || !n.layout) return !1;
+    n.root && (n.root.scroll = void 0, n.root.updateScroll());
+    const s = Rl(i, n.root, this.visualElement.getTransformPagePoint());
+    let o = wc(n.layout.layoutBox, s);
+    if (e) {
+      const r = e(Cl(o));
+      this.hasMutatedConstraints = !!r, r && (o = rr(r));
+    }
+    return o;
+  }
+  startAnimation(t) {
+    const { drag: e, dragMomentum: i, dragElastic: n, dragTransition: s, dragSnapToOrigin: o, onDragTransitionEnd: r } = this.getProps(), a = this.constraints || {}, l = q((c) => {
+      if (!Gt(c, e, this.currentDirection)) return;
+      let u = a && a[c] || {};
+      (o === !0 || o === c) && (u = {
+        min: 0,
+        max: 0
+      });
+      const h = n ? 200 : 1e6, f = n ? 40 : 1e7, p = {
+        type: "inertia",
+        velocity: i ? t[c] : 0,
+        bounceStiffness: h,
+        bounceDamping: f,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...s,
+        ...u
+      };
+      return this.startAxisValueAnimation(c, p);
+    });
+    return Promise.all(l).then(r);
+  }
+  startAxisValueAnimation(t, e) {
+    const i = this.getAxisMotionValue(t);
+    return ze(this.visualElement, t), i.start(yi(t, i, 0, e, this.visualElement, !1));
+  }
+  stopAnimation() {
+    q((t) => this.getAxisMotionValue(t).stop());
+  }
+  getAxisMotionValue(t) {
+    const e = `_drag${t.toUpperCase()}`, i = this.visualElement.getProps()[e];
+    return i || this.visualElement.getValue(t, this.visualElement.latestValues[t] ?? 0);
+  }
+  snapToCursor(t) {
+    q((e) => {
+      const { drag: i } = this.getProps();
+      if (!Gt(e, i, this.currentDirection)) return;
+      const { projection: n } = this.visualElement, s = this.getAxisMotionValue(e);
+      if (n && n.layout) {
+        const { min: o, max: r } = n.layout.layoutBox[e], a = s.get() || 0;
+        s.set(t[e] - V(o, r, 0.5) + a);
+      }
+    });
+  }
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current) return;
+    const { drag: t, dragConstraints: e } = this.getProps(), { projection: i } = this.visualElement;
+    if (!Tt(e) || !i || !this.constraints) return;
+    this.stopAnimation();
+    const n = {
+      x: 0,
+      y: 0
+    };
+    q((o) => {
+      const r = this.getAxisMotionValue(o);
+      if (r && this.constraints !== !1) {
+        const a = r.get();
+        n[o] = Pc({
+          min: a,
+          max: a
+        }, this.constraints[o]);
+      }
+    });
+    const { transformTemplate: s } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = s ? s({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.constraints = !1, this.resolveConstraints(), q((o) => {
+      if (!Gt(o, t, null)) return;
+      const r = this.getAxisMotionValue(o), { min: a, max: l } = this.constraints[o];
+      r.set(V(a, l, n[o]));
+    }), this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current) return;
+    Ac.set(this.visualElement, this);
+    const t = this.visualElement.current, e = It(t, "pointerdown", (l) => {
+      const { drag: c, dragListener: u = !0 } = this.getProps(), h = l.target, f = h !== t && ll(h);
+      c && u && !f && this.start(l);
+    });
+    let i;
+    const n = () => {
+      const { dragConstraints: l } = this.getProps();
+      Tt(l) && l.current && (this.constraints = this.resolveRefConstraints(), i || (i = Mc(t, l.current, () => this.scalePositionWithinConstraints())));
+    }, { projection: s } = this.visualElement, o = s.addEventListener("measure", n);
+    s && !s.layout && (s.root && s.root.updateScroll(), s.updateLayout()), M.read(n);
+    const r = Nt(window, "resize", () => this.scalePositionWithinConstraints()), a = s.addEventListener("didUpdate", (({ delta: l, hasLayoutChanged: c }) => {
+      this.isDragging && c && (q((u) => {
+        const h = this.getAxisMotionValue(u);
+        h && (this.originPoint[u] += l[u].translate, h.set(h.get() + l[u].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      r(), e(), o(), a && a(), i && i();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: e = !1, dragDirectionLock: i = !1, dragPropagation: n = !1, dragConstraints: s = !1, dragElastic: o = ei, dragMomentum: r = !0 } = t;
+    return {
+      ...t,
+      drag: e,
+      dragDirectionLock: i,
+      dragPropagation: n,
+      dragConstraints: s,
+      dragElastic: o,
+      dragMomentum: r
+    };
+  }
+};
+function Gn(t) {
+  let e = !0;
+  return () => {
+    if (e) {
+      e = !1;
+      return;
+    }
+    t();
+  };
+}
+function Mc(t, e, i) {
+  const n = en(t, Gn(i)), s = en(e, Gn(i));
+  return () => {
+    n(), s();
+  };
+}
+function Gt(t, e, i) {
+  return (e === !0 || e === t) && (i === null || i === t);
+}
+function Cc(t, e = 10) {
+  let i = null;
+  return Math.abs(t.y) > e ? i = "y" : Math.abs(t.x) > e && (i = "x"), i;
+}
+var Dc = class extends ot {
+  constructor(t) {
+    super(t), this.removeGroupControls = _, this.removeListeners = _, this.controls = new Vc(t);
+  }
+  mount() {
+    const { dragControls: t } = this.node.getProps();
+    t && (this.removeGroupControls = t.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || _;
+  }
+  update() {
+    const { dragControls: t } = this.node.getProps(), { dragControls: e } = this.node.prevProps || {};
+    t !== e && (this.removeGroupControls(), t && (this.removeGroupControls = t.subscribe(this.controls)));
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
+  }
+}, Ce = (t) => (e, i) => {
+  t && M.update(() => t(e, i), !1, !0);
+}, Ec = class extends ot {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = _;
+  }
+  onPointerDown(t) {
+    this.session = new Ir(t, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: Br(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: t, onPanStart: e, onPan: i, onPanEnd: n } = this.node.getProps();
+    return {
+      onSessionStart: Ce(t),
+      onStart: Ce(e),
+      onMove: Ce(i),
+      onEnd: (s, o) => {
+        delete this.session, n && M.postRender(() => n(s, o));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = It(this.node.current, "pointerdown", (t) => this.onPointerDown(t));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+}, De = !1, Rc = class extends $r {
+  componentDidMount() {
+    const { visualElement: t, layoutGroup: e, switchLayoutGroup: i, layoutId: n } = this.props, { projection: s } = t;
+    s && (e.group && e.group.add(s), i && i.register && n && i.register(s), De && s.root.didUpdate(), s.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), s.setOptions({
+      ...s.options,
+      layoutDependency: this.props.layoutDependency,
+      onExitComplete: () => this.safeToRemove()
+    })), ee.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(t) {
+    const { layoutDependency: e, visualElement: i, drag: n, isPresent: s } = this.props, { projection: o } = i;
+    return o && (o.isPresent = s, t.layoutDependency !== e && o.setOptions({
+      ...o.options,
+      layoutDependency: e
+    }), De = !0, n || t.layoutDependency !== e || e === void 0 || t.isPresent !== s ? o.willUpdate() : this.safeToRemove(), t.isPresent !== s && (s ? o.promote() : o.relegate() || M.postRender(() => {
+      const r = o.getStack();
+      (!r || !r.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { visualElement: t, layoutAnchor: e } = this.props, { projection: i } = t;
+    i && (i.options.layoutAnchor = e, i.root.didUpdate(), Pi.postRender(() => {
+      !i.currentAnimation && i.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: t, layoutGroup: e, switchLayoutGroup: i } = this.props, { projection: n } = t;
+    De = !0, n && (n.scheduleCheckAfterUnmount(), e && e.group && e.group.remove(n), i && i.deregister && i.deregister(n));
+  }
+  safeToRemove() {
+    const { safeToRemove: t } = this.props;
+    t && t();
+  }
+  render() {
+    return null;
+  }
+};
+function Or(t) {
+  const [e, i] = Fu(), n = U(ts);
+  return Qn(Rc, {
+    ...t,
+    layoutGroup: n,
+    switchLayoutGroup: U(Lr),
+    isPresent: e,
+    safeToRemove: i
+  });
+}
+var Lc = {
+  pan: { Feature: Ec },
+  drag: {
+    Feature: Dc,
+    ProjectionNode: Sr,
+    MeasureLayout: Or
+  }
+};
+function Xn(t, e, i) {
+  const { props: n } = t;
+  t.animationState && n.whileHover && t.animationState.setActive("whileHover", i === "Start");
+  const s = n["onHover" + i];
+  s && M.postRender(() => s(e, Kt(e)));
+}
+var kc = class extends ot {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = sl(t, (e, i) => (Xn(this.node, i, "Start"), (n) => Xn(this.node, n, "End"))));
+  }
+  unmount() {
+  }
+}, Bc = class extends ot {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.node.current.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    !t || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = Ut(Nt(this.node.current, "focus", () => this.onFocus()), Nt(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+};
+function Yn(t, e, i) {
+  const { props: n } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled) return;
+  t.animationState && n.whileTap && t.animationState.setActive("whileTap", i === "Start");
+  const s = n["onTap" + (i === "End" ? "" : i)];
+  s && M.postRender(() => s(e, Kt(e)));
+}
+var Ic = class extends ot {
+  mount() {
+    const { current: t } = this.node;
+    if (!t) return;
+    const { globalTapTarget: e, propagate: i } = this.node.props;
+    this.unmount = cl(t, (n, s) => (Yn(this.node, s, "Start"), (o, { success: r }) => Yn(this.node, o, r ? "End" : "Cancel")), {
+      useGlobalTarget: e,
+      stopPropagation: i?.tap === !1
+    });
+  }
+  unmount() {
+  }
+}, ii = /* @__PURE__ */ new WeakMap(), Ee = /* @__PURE__ */ new WeakMap(), Fc = (t) => {
+  const e = ii.get(t.target);
+  e && e(t);
+}, Oc = (t) => {
+  t.forEach(Fc);
+};
+function jc({ root: t, ...e }) {
+  const i = t || document;
+  Ee.has(i) || Ee.set(i, {});
+  const n = Ee.get(i), s = JSON.stringify(e);
+  return n[s] || (n[s] = new IntersectionObserver(Oc, {
+    root: t,
+    ...e
+  })), n[s];
+}
+function Nc(t, e, i) {
+  const n = jc(e);
+  return ii.set(t, i), n.observe(t), () => {
+    ii.delete(t), n.unobserve(t);
+  };
+}
+var Uc = {
+  some: 0,
+  all: 1
+}, Wc = class extends ot {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.stopObserver?.();
+    const { viewport: t = {} } = this.node.getProps(), { root: e, margin: i, amount: n = "some", once: s } = t, o = {
+      root: e ? e.current : void 0,
+      rootMargin: i,
+      threshold: typeof n == "number" ? n : Uc[n]
+    }, r = (a) => {
+      const { isIntersecting: l } = a;
+      if (this.isInView === l || (this.isInView = l, s && !l && this.hasEnteredView)) return;
+      l && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", l);
+      const { onViewportEnter: c, onViewportLeave: u } = this.node.getProps(), h = l ? c : u;
+      h && h(a);
+    };
+    this.stopObserver = Nc(this.node.current, o, r);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u") return;
+    const { props: t, prevProps: e } = this.node;
+    [
+      "amount",
+      "margin",
+      "root"
+    ].some($c(t, e)) && this.startObserver();
+  }
+  unmount() {
+    this.stopObserver?.(), this.hasEnteredView = !1, this.isInView = !1;
+  }
+};
+function $c({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (i) => t[i] !== e[i];
+}
+var Kc = {
+  inView: { Feature: Wc },
+  tap: { Feature: Ic },
+  focus: { Feature: Bc },
+  hover: { Feature: kc }
+}, _c = { layout: {
+  ProjectionNode: Sr,
+  MeasureLayout: Or
+} }, zc = {
+  ...pc,
+  ...Kc,
+  ...Lc,
+  ..._c
+}, Hc = /* @__PURE__ */ uc(zc, cc), Jc = Hc;
+export {
+  Jc as t
+};