@jenesei-software/jenesei-kit-react 1.3.40 → 2.0.1

package/build/proxy-wCWa57J3.js

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