quantum-component-library 1.4.45-qa.2 → 1.4.45-qa.3

package/dist/framer-motion-vendor-Cn84b4iY.js

@@ -0,0 +1,3285 @@
+import { _ as y, i as gt, n as Ie, a as de, p as V, b as er, d as at, s as Yt, e as Z, f as Be, g as M, h as fa, k as la, l as ca, m as va, o as da, q as ma, r as pa, t as ga, v as ha, w as ya, x as Pa, y as ba, z as Ta, A as xa, B as Aa, C as At, D as Pe, E as G, F as Zr, G as Va, H as Sa, I as K, J as Ca, K as Ea, L as La, M as wa, N as qr, O as J, P as be, Q as Ra, R as $r } from "./vendor-BvxNWBst.js";
+import * as U from "react";
+import Jr, { createContext as ht, useContext as O, useRef as $, useEffect as Q, useLayoutEffect as Da, useCallback as Qr, useMemo as wt, forwardRef as Ma, createElement as Fa, useState as Ia, cloneElement as Ba, Children as Oa, isValidElement as ja } from "react";
+var et = function(t) {
+  return {
+    isEnabled: function(e) {
+      return t.some(function(r) {
+        return !!e[r];
+      });
+    }
+  };
+}, Oe = {
+  measureLayout: et([
+    "layout",
+    "layoutId",
+    "drag",
+    "_layoutResetTransform"
+  ]),
+  animation: et([
+    "animate",
+    "exit",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "whileFocus",
+    "whileDrag"
+  ]),
+  exit: et(["exit"]),
+  drag: et(["drag", "dragControls"]),
+  focus: et(["whileFocus"]),
+  hover: et(["whileHover", "onHoverStart", "onHoverEnd"]),
+  tap: et(["whileTap", "onTap", "onTapStart", "onTapCancel"]),
+  pan: et([
+    "onPan",
+    "onPanStart",
+    "onPanSessionStart",
+    "onPanEnd"
+  ]),
+  layoutAnimation: et(["layout", "layoutId"])
+};
+function Ha(t) {
+  for (var e in t) {
+    var r = t[e];
+    r !== null && (Oe[e].Component = r);
+  }
+}
+var kr = ht({ strict: !1 }), tn = Object.keys(Oe), _a = tn.length;
+function Ua(t, e, r) {
+  var n = [], a = O(kr);
+  if (!e)
+    return null;
+  process.env.NODE_ENV !== "production" && r && a.strict && gt(!1, "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.");
+  for (var i = 0; i < _a; i++) {
+    var o = tn[i], u = Oe[o], f = u.isEnabled, s = u.Component;
+    f(t) && s && n.push(U.createElement(s, y({ key: o }, t, { visualElement: e })));
+  }
+  return n;
+}
+var ae = ht({
+  transformPagePoint: function(t) {
+    return t;
+  },
+  isStatic: !1
+}), ie = ht({});
+function Na() {
+  return O(ie).visualElement;
+}
+var St = ht(null);
+function Rt(t) {
+  var e = $(null);
+  return e.current === null && (e.current = t()), e.current;
+}
+function en() {
+  var t = O(St);
+  if (t === null)
+    return [!0, null];
+  var e = t.isPresent, r = t.onExitComplete, n = t.register, a = Xa();
+  Q(function() {
+    return n(a);
+  }, []);
+  var i = function() {
+    return r?.(a);
+  };
+  return !e && r ? [!1, i] : [!0];
+}
+function es() {
+  return rn(O(St));
+}
+function rn(t) {
+  return t === null ? !0 : t.isPresent;
+}
+var Ka = 0, Ya = function() {
+  return Ka++;
+}, Xa = function() {
+  return Rt(Ya);
+}, za = ht(null), jt = typeof window < "u", rr = jt ? Da : Q;
+function Ga(t) {
+  var e = t.layoutId, r = O(za);
+  return r && e !== void 0 ? r + "-" + e : e;
+}
+function Wa(t, e, r, n) {
+  var a = O(ae), i = O(kr), o = Na(), u = O(St), f = Ga(r), s = $(void 0);
+  n || (n = i.renderer), !s.current && n && (s.current = n(t, {
+    visualState: e,
+    parent: o,
+    props: y(y({}, r), { layoutId: f }),
+    presenceId: u?.id,
+    blockInitialAnimation: u?.initial === !1
+  }));
+  var l = s.current;
+  return rr(function() {
+    l && (l.setProps(y(y(y({}, a), r), { layoutId: f })), l.isPresent = rn(u), l.isPresenceRoot = !o || o.presenceId !== u?.id, l.syncRender());
+  }), Q(function() {
+    var p;
+    l && ((p = l.animationState) === null || p === void 0 || p.animateChanges());
+  }), rr(function() {
+    return function() {
+      return l?.notifyUnmount();
+    };
+  }, []), l;
+}
+function Te(t) {
+  return typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+function Za(t, e, r) {
+  return Qr(
+    function(n) {
+      var a;
+      n && ((a = t.mount) === null || a === void 0 || a.call(t, n)), e && (n ? e.mount(n) : e.unmount()), r && (typeof r == "function" ? r(n) : Te(r) && (r.current = n));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [e]
+  );
+}
+function nn(t) {
+  return Array.isArray(t);
+}
+function W(t) {
+  return typeof t == "string" || nn(t);
+}
+function qa(t) {
+  var e = {};
+  return t.forEachValue(function(r, n) {
+    return e[n] = r.get();
+  }), e;
+}
+function $a(t) {
+  var e = {};
+  return t.forEachValue(function(r, n) {
+    return e[n] = r.getVelocity();
+  }), e;
+}
+function an(t, e, r, n, a) {
+  var i;
+  return n === void 0 && (n = {}), a === void 0 && (a = {}), typeof e == "string" && (e = (i = t.variants) === null || i === void 0 ? void 0 : i[e]), typeof e == "function" ? e(r ?? t.custom, n, a) : e;
+}
+function oe(t, e, r) {
+  var n = t.getProps();
+  return an(n, e, r ?? n.custom, qa(t), $a(t));
+}
+function ue(t) {
+  var e;
+  return typeof ((e = t.animate) === null || e === void 0 ? void 0 : e.start) == "function" || W(t.initial) || W(t.animate) || W(t.whileHover) || W(t.whileDrag) || W(t.whileTap) || W(t.whileFocus) || W(t.exit);
+}
+function on(t) {
+  return !!(ue(t) || t.variants);
+}
+function Ja(t, e) {
+  if (ue(t)) {
+    var r = t.initial, n = t.animate;
+    return {
+      initial: r === !1 || W(r) ? r : void 0,
+      animate: W(n) ? n : void 0
+    };
+  }
+  return t.inherit !== !1 ? e : {};
+}
+function Qa(t, e) {
+  var r = Ja(t, O(ie)), n = r.initial, a = r.animate;
+  return wt(
+    function() {
+      return { initial: n, animate: a };
+    },
+    /**
+     * Only break memoisation in static mode
+     */
+    e ? [
+      nr(n),
+      nr(a)
+    ] : []
+  );
+}
+function nr(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+function ka(t) {
+  var e = t.preloadedFeatures, r = t.createVisualElement, n = t.useRender, a = t.useVisualState, i = t.Component;
+  e && Ha(e);
+  function o(u, f) {
+    var s = O(ae).isStatic, l = null, p = Qa(u, s), c = a(u, s);
+    return !s && jt && (p.visualElement = Wa(i, c, u, r), l = Ua(u, p.visualElement, e)), U.createElement(
+      U.Fragment,
+      null,
+      U.createElement(ie.Provider, { value: p }, n(i, u, Za(c, p.visualElement, f), c, s)),
+      l
+    );
+  }
+  return Ma(o);
+}
+function ti(t) {
+  function e(n, a) {
+    return a === void 0 && (a = {}), ka(t(n, a));
+  }
+  var r = /* @__PURE__ */ new Map();
+  return new Proxy(e, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: function(n, a) {
+      return r.has(a) || r.set(a, e(a)), r.get(a);
+    }
+  });
+}
+var ei = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+function je(t) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof t != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    t.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(ei.indexOf(t) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/.test(t))
+    )
+  );
+}
+var Et = {};
+function ri(t) {
+  for (var e in t)
+    Et[e] = t[e];
+}
+var ni = ["", "X", "Y", "Z"], ai = ["translate", "scale", "rotate", "skew"], Dt = ["transformPerspective", "x", "y", "z"];
+ai.forEach(function(t) {
+  return ni.forEach(function(e) {
+    return Dt.push(t + e);
+  });
+});
+function ii(t, e) {
+  return Dt.indexOf(t) - Dt.indexOf(e);
+}
+var oi = new Set(Dt);
+function se(t) {
+  return oi.has(t);
+}
+var ui = /* @__PURE__ */ new Set(["originX", "originY", "originZ"]);
+function un(t) {
+  return ui.has(t);
+}
+function sn(t, e) {
+  var r = e.layout, n = e.layoutId;
+  return se(t) || un(t) || (r || n !== void 0) && (!!Et[t] || t === "opacity");
+}
+var it = function(t) {
+  return t !== null && typeof t == "object" && t.getVelocity;
+}, si = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+};
+function fi(t, e, r, n) {
+  var a = t.transform, i = t.transformKeys, o = e.enableHardwareAcceleration, u = o === void 0 ? !0 : o, f = e.allowTransformNone, s = f === void 0 ? !0 : f, l = "";
+  i.sort(ii);
+  for (var p = !1, c = i.length, d = 0; d < c; d++) {
+    var v = i[d];
+    l += (si[v] || v) + "(" + a[v] + ") ", v === "z" && (p = !0);
+  }
+  return !p && u ? l += "translateZ(0)" : l = l.trim(), n ? l = n(a, r ? "" : l) : s && r && (l = "none"), l;
+}
+function li(t) {
+  var e = t.originX, r = e === void 0 ? "50%" : e, n = t.originY, a = n === void 0 ? "50%" : n, i = t.originZ, o = i === void 0 ? 0 : i;
+  return r + " " + a + " " + o;
+}
+function fn(t) {
+  return t.startsWith("--");
+}
+var ci = function(t, e) {
+  return e && typeof t == "number" ? e.transform(t) : t;
+}, ar = y(y({}, Ie), { transform: Math.round }), ln = {
+  // Border props
+  borderWidth: V,
+  borderTopWidth: V,
+  borderRightWidth: V,
+  borderBottomWidth: V,
+  borderLeftWidth: V,
+  borderRadius: V,
+  radius: V,
+  borderTopLeftRadius: V,
+  borderTopRightRadius: V,
+  borderBottomRightRadius: V,
+  borderBottomLeftRadius: V,
+  // Positioning props
+  width: V,
+  maxWidth: V,
+  height: V,
+  maxHeight: V,
+  size: V,
+  top: V,
+  right: V,
+  bottom: V,
+  left: V,
+  // Spacing props
+  padding: V,
+  paddingTop: V,
+  paddingRight: V,
+  paddingBottom: V,
+  paddingLeft: V,
+  margin: V,
+  marginTop: V,
+  marginRight: V,
+  marginBottom: V,
+  marginLeft: V,
+  // Transform props
+  rotate: at,
+  rotateX: at,
+  rotateY: at,
+  rotateZ: at,
+  scale: Yt,
+  scaleX: Yt,
+  scaleY: Yt,
+  scaleZ: Yt,
+  skew: at,
+  skewX: at,
+  skewY: at,
+  distance: V,
+  translateX: V,
+  translateY: V,
+  translateZ: V,
+  x: V,
+  y: V,
+  z: V,
+  perspective: V,
+  transformPerspective: V,
+  opacity: de,
+  originX: er,
+  originY: er,
+  originZ: V,
+  // Misc
+  zIndex: ar,
+  // SVG
+  fillOpacity: de,
+  strokeOpacity: de,
+  numOctaves: ar
+};
+function He(t, e, r, n, a, i, o, u) {
+  var f, s = t.style, l = t.vars, p = t.transform, c = t.transformKeys, d = t.transformOrigin;
+  c.length = 0;
+  var v = !1, P = !1, m = !0;
+  for (var h in e) {
+    var A = e[h];
+    if (fn(h)) {
+      l[h] = A;
+      continue;
+    }
+    var L = ln[h], D = ci(A, L);
+    if (se(h)) {
+      if (v = !0, p[h] = D, c.push(h), !m)
+        continue;
+      A !== ((f = L.default) !== null && f !== void 0 ? f : 0) && (m = !1);
+    } else if (un(h))
+      d[h] = D, P = !0;
+    else if (r?.isHydrated && n?.isHydrated && Et[h]) {
+      var C = Et[h].process(A, n, r), x = Et[h].applyTo;
+      if (x)
+        for (var w = x.length, E = 0; E < w; E++)
+          s[x[E]] = C;
+      else
+        s[h] = C;
+    } else
+      s[h] = D;
+  }
+  n && r && o && u ? (s.transform = o(n.deltaFinal, n.treeScale, v ? p : void 0), i && (s.transform = i(p, s.transform)), s.transformOrigin = u(n)) : (v && (s.transform = fi(t, a, m, i)), P && (s.transformOrigin = li(d)));
+}
+var _e = function() {
+  return {
+    style: {},
+    transform: {},
+    transformKeys: [],
+    transformOrigin: {},
+    vars: {}
+  };
+};
+function cn(t, e, r) {
+  for (var n in e)
+    !it(e[n]) && !sn(n, r) && (t[n] = e[n]);
+}
+function vi(t, e, r) {
+  var n = t.transformTemplate;
+  return wt(function() {
+    var a = _e();
+    He(a, e, void 0, void 0, { enableHardwareAcceleration: !r }, n);
+    var i = a.vars, o = a.style;
+    return y(y({}, i), o);
+  }, [e]);
+}
+function di(t, e, r) {
+  var n = t.style || {}, a = {};
+  return cn(a, n, t), Object.assign(a, vi(t, e, r)), t.transformValues && (a = t.transformValues(a)), a;
+}
+function mi(t, e, r) {
+  var n = {}, a = di(t, e, r);
+  return t.drag && (n.draggable = !1, a.userSelect = a.WebkitUserSelect = a.WebkitTouchCallout = "none", a.touchAction = t.drag === !0 ? "none" : "pan-" + (t.drag === "x" ? "y" : "x")), n.style = a, n;
+}
+var pi = /* @__PURE__ */ new Set([
+  "initial",
+  "animate",
+  "exit",
+  "style",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "transformValues",
+  "custom",
+  "inherit",
+  "layout",
+  "layoutId",
+  "_layoutResetTransform",
+  "onLayoutAnimationComplete",
+  "onViewportBoxUpdate",
+  "onLayoutMeasure",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "drag",
+  "dragControls",
+  "dragListener",
+  "dragConstraints",
+  "dragDirectionLock",
+  "_dragX",
+  "_dragY",
+  "dragElastic",
+  "dragMomentum",
+  "dragPropagation",
+  "dragTransition",
+  "whileDrag",
+  "onPan",
+  "onPanStart",
+  "onPanEnd",
+  "onPanSessionStart",
+  "onTap",
+  "onTapStart",
+  "onTapCancel",
+  "onHoverStart",
+  "onHoverEnd",
+  "whileFocus",
+  "whileTap",
+  "whileHover"
+]);
+function Qt(t) {
+  return pi.has(t);
+}
+var vn = function(t) {
+  return !Qt(t);
+};
+try {
+  var gi = require("@emotion/is-prop-valid").default;
+  vn = function(t) {
+    return t.startsWith("on") ? !Qt(t) : gi(t);
+  };
+} catch {
+}
+function hi(t, e, r) {
+  var n = {};
+  for (var a in t)
+    (vn(a) || r === !0 && Qt(a) || !e && !Qt(a)) && (n[a] = t[a]);
+  return n;
+}
+function ir(t, e, r) {
+  return typeof t == "string" ? t : V.transform(e + r * t);
+}
+function yi(t, e, r) {
+  var n = ir(e, t.x, t.width), a = ir(r, t.y, t.height);
+  return n + " " + a;
+}
+var me = function(t, e) {
+  return V.transform(t * e);
+}, Pi = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function bi(t, e, r, n, a, i) {
+  n === void 0 && (n = 1), a === void 0 && (a = 0);
+  var o = Pi;
+  t[o.offset] = me(-a, e);
+  var u = me(r, e), f = me(n, e);
+  t[o.array] = u + " " + f;
+}
+function Ue(t, e, r, n, a, i, o, u) {
+  var f = e.attrX, s = e.attrY, l = e.originX, p = e.originY, c = e.pathLength, d = e.pathSpacing, v = d === void 0 ? 1 : d, P = e.pathOffset, m = P === void 0 ? 0 : P, h = Z(e, ["attrX", "attrY", "originX", "originY", "pathLength", "pathSpacing", "pathOffset"]);
+  He(t, h, r, n, a, i, o, u), t.attrs = t.style, t.style = {};
+  var A = t.attrs, L = t.style, D = t.dimensions, C = t.totalPathLength;
+  A.transform && (D && (L.transform = A.transform), delete A.transform), D && (l !== void 0 || p !== void 0 || L.transform) && (L.transformOrigin = yi(D, l !== void 0 ? l : 0.5, p !== void 0 ? p : 0.5)), f !== void 0 && (A.x = f), s !== void 0 && (A.y = s), C !== void 0 && c !== void 0 && bi(A, C, c, v, m);
+}
+var dn = function() {
+  return y(y({}, _e()), { attrs: {} });
+};
+function Ti(t, e) {
+  var r = wt(function() {
+    var a = dn();
+    return Ue(a, e, void 0, void 0, { enableHardwareAcceleration: !1 }, t.transformTemplate), y(y({}, a.attrs), { style: y({}, a.style) });
+  }, [e]);
+  if (t.style) {
+    var n = {};
+    cn(n, t.style, t), r.style = y(y({}, n), r.style);
+  }
+  return r;
+}
+function xi(t) {
+  t === void 0 && (t = !1);
+  var e = function(r, n, a, i, o) {
+    var u = i.latestValues, f = je(r) ? Ti : mi, s = f(n, u, o), l = hi(n, typeof r == "string", t), p = y(y(y({}, l), s), { ref: a });
+    return Fa(r, p);
+  };
+  return e;
+}
+var Ai = /([a-z])([A-Z])/g, Vi = "$1-$2", mn = function(t) {
+  return t.replace(Ai, Vi).toLowerCase();
+};
+function pn(t, e) {
+  var r = e.style, n = e.vars;
+  Object.assign(t.style, r);
+  for (var a in n)
+    t.style.setProperty(a, n[a]);
+}
+var gn = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform"
+]);
+function hn(t, e) {
+  pn(t, e);
+  for (var r in e.attrs)
+    t.setAttribute(gn.has(r) ? r : mn(r), e.attrs[r]);
+}
+function Ne(t) {
+  var e = t.style, r = {};
+  for (var n in e)
+    (it(e[n]) || sn(n, t)) && (r[n] = e[n]);
+  return r;
+}
+function yn(t) {
+  var e = Ne(t);
+  for (var r in t)
+    if (it(t[r])) {
+      var n = r === "x" || r === "y" ? "attr" + r.toUpperCase() : r;
+      e[n] = t[r];
+    }
+  return e;
+}
+function Ke(t) {
+  return typeof t == "object" && typeof t.start == "function";
+}
+var Mt = function(t) {
+  return Array.isArray(t);
+}, Si = function(t) {
+  return !!(t && typeof t == "object" && t.mix && t.toValue);
+}, Ci = function(t) {
+  return Mt(t) ? t[t.length - 1] || 0 : t;
+};
+function Ei(t) {
+  var e = it(t) ? t.get() : t;
+  return Si(e) ? e.toValue() : e;
+}
+function or(t, e, r, n) {
+  var a = t.scrapeMotionValuesFromProps, i = t.createRenderState, o = t.onMount, u = {
+    latestValues: Li(e, r, n, a),
+    renderState: i()
+  };
+  return o && (u.mount = function(f) {
+    return o(e, f, u);
+  }), u;
+}
+var Pn = function(t) {
+  return function(e, r) {
+    var n = O(ie), a = O(St);
+    return r ? or(t, e, n, a) : Rt(function() {
+      return or(t, e, n, a);
+    });
+  };
+};
+function Li(t, e, r, n) {
+  var a = {}, i = r?.initial === !1, o = n(t);
+  for (var u in o)
+    a[u] = Ei(o[u]);
+  var f = t.initial, s = t.animate, l = ue(t), p = on(t);
+  e && p && !l && t.inherit !== !1 && (f ?? (f = e.initial), s ?? (s = e.animate));
+  var c = i || f === !1 ? s : f;
+  if (c && typeof c != "boolean" && !Ke(c)) {
+    var d = Array.isArray(c) ? c : [c];
+    d.forEach(function(v) {
+      var P = an(t, v);
+      if (P) {
+        var m = P.transitionEnd;
+        P.transition;
+        var h = Z(P, ["transitionEnd", "transition"]);
+        for (var A in h)
+          a[A] = h[A];
+        for (var A in m)
+          a[A] = m[A];
+      }
+    });
+  }
+  return a;
+}
+var wi = {
+  useVisualState: Pn({
+    scrapeMotionValuesFromProps: yn,
+    createRenderState: dn,
+    onMount: function(t, e, r) {
+      var n = r.renderState, a = r.latestValues;
+      try {
+        n.dimensions = typeof e.getBBox == "function" ? e.getBBox() : e.getBoundingClientRect();
+      } catch {
+        n.dimensions = {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        };
+      }
+      Ri(e) && (n.totalPathLength = e.getTotalLength()), Ue(n, a, void 0, void 0, { enableHardwareAcceleration: !1 }, t.transformTemplate), hn(e, n);
+    }
+  })
+};
+function Ri(t) {
+  return t.tagName === "path";
+}
+var Di = {
+  useVisualState: Pn({
+    scrapeMotionValuesFromProps: Ne,
+    createRenderState: _e
+  })
+};
+function Mi(t, e, r, n) {
+  var a = e.forwardMotionProps, i = a === void 0 ? !1 : a, o = je(t) ? wi : Di;
+  return y(y({}, o), {
+    preloadedFeatures: r,
+    useRender: xi(i),
+    createVisualElement: n,
+    Component: t
+  });
+}
+var F;
+(function(t) {
+  t.Animate = "animate", t.Hover = "whileHover", t.Tap = "whileTap", t.Drag = "whileDrag", t.Focus = "whileFocus", t.Exit = "exit";
+})(F || (F = {}));
+function Ye(t, e, r, n) {
+  return t.addEventListener(e, r, n), function() {
+    return t.removeEventListener(e, r, n);
+  };
+}
+function xe(t, e, r, n) {
+  Q(function() {
+    var a = t.current;
+    if (r && a)
+      return Ye(a, e, r, n);
+  }, [t, e, r, n]);
+}
+function Fi(t) {
+  var e = t.whileFocus, r = t.visualElement, n = function() {
+    var i;
+    (i = r.animationState) === null || i === void 0 || i.setActive(F.Focus, !0);
+  }, a = function() {
+    var i;
+    (i = r.animationState) === null || i === void 0 || i.setActive(F.Focus, !1);
+  };
+  xe(r, "focus", e ? n : void 0), xe(r, "blur", e ? a : void 0);
+}
+function bn(t) {
+  return typeof PointerEvent < "u" && t instanceof PointerEvent ? t.pointerType === "mouse" : t instanceof MouseEvent;
+}
+function Tn(t) {
+  var e = !!t.touches;
+  return e;
+}
+function Ii(t) {
+  return function(e) {
+    var r = e instanceof MouseEvent, n = !r || r && e.button === 0;
+    n && t(e);
+  };
+}
+var Bi = { pageX: 0, pageY: 0 };
+function Oi(t, e) {
+  e === void 0 && (e = "page");
+  var r = t.touches[0] || t.changedTouches[0], n = r || Bi;
+  return {
+    x: n[e + "X"],
+    y: n[e + "Y"]
+  };
+}
+function ji(t, e) {
+  return e === void 0 && (e = "page"), {
+    x: t[e + "X"],
+    y: t[e + "Y"]
+  };
+}
+function Xe(t, e) {
+  return e === void 0 && (e = "page"), {
+    point: Tn(t) ? Oi(t, e) : ji(t, e)
+  };
+}
+function Hi(t) {
+  return Xe(t, "client");
+}
+var xn = function(t, e) {
+  e === void 0 && (e = !1);
+  var r = function(n) {
+    return t(n, Xe(n));
+  };
+  return e ? Ii(r) : r;
+}, _i = function() {
+  return jt && window.onpointerdown === null;
+}, Ui = function() {
+  return jt && window.ontouchstart === null;
+}, Ni = function() {
+  return jt && window.onmousedown === null;
+}, Ki = {
+  pointerdown: "mousedown",
+  pointermove: "mousemove",
+  pointerup: "mouseup",
+  pointercancel: "mousecancel",
+  pointerover: "mouseover",
+  pointerout: "mouseout",
+  pointerenter: "mouseenter",
+  pointerleave: "mouseleave"
+}, Yi = {
+  pointerdown: "touchstart",
+  pointermove: "touchmove",
+  pointerup: "touchend",
+  pointercancel: "touchcancel"
+};
+function An(t) {
+  return _i() ? t : Ui() ? Yi[t] : Ni() ? Ki[t] : t;
+}
+function Tt(t, e, r, n) {
+  return Ye(t, An(e), xn(r, e === "pointerdown"), n);
+}
+function kt(t, e, r, n) {
+  return xe(t, An(e), r && xn(r, e === "pointerdown"), n);
+}
+function Vn(t) {
+  var e = null;
+  return function() {
+    var r = function() {
+      e = null;
+    };
+    return e === null ? (e = t, r) : !1;
+  };
+}
+var ur = Vn("dragHorizontal"), sr = Vn("dragVertical");
+function Sn(t) {
+  var e = !1;
+  if (t === "y")
+    e = sr();
+  else if (t === "x")
+    e = ur();
+  else {
+    var r = ur(), n = sr();
+    r && n ? e = function() {
+      r(), n();
+    } : (r && r(), n && n());
+  }
+  return e;
+}
+function Cn() {
+  var t = Sn(!0);
+  return t ? (t(), !1) : !0;
+}
+function fr(t, e, r) {
+  return function(n, a) {
+    var i;
+    !bn(n) || Cn() || (r?.(n, a), (i = t.animationState) === null || i === void 0 || i.setActive(F.Hover, e));
+  };
+}
+function Xi(t) {
+  var e = t.onHoverStart, r = t.onHoverEnd, n = t.whileHover, a = t.visualElement;
+  kt(a, "pointerenter", e || n ? fr(a, !0, e) : void 0), kt(a, "pointerleave", r || n ? fr(a, !1, r) : void 0);
+}
+var En = function(t, e) {
+  return e ? t === e ? !0 : En(t, e.parentElement) : !1;
+};
+function ze(t) {
+  return Q(function() {
+    return function() {
+      return t();
+    };
+  }, []);
+}
+function zi(t) {
+  var e = t.onTap, r = t.onTapStart, n = t.onTapCancel, a = t.whileTap, i = t.visualElement, o = e || r || n || a, u = $(!1), f = $(null);
+  function s() {
+    var v;
+    (v = f.current) === null || v === void 0 || v.call(f), f.current = null;
+  }
+  function l() {
+    var v;
+    return s(), u.current = !1, (v = i.animationState) === null || v === void 0 || v.setActive(F.Tap, !1), !Cn();
+  }
+  function p(v, P) {
+    l() && (En(i.getInstance(), v.target) ? e?.(v, P) : n?.(v, P));
+  }
+  function c(v, P) {
+    l() && n?.(v, P);
+  }
+  function d(v, P) {
+    var m;
+    s(), !u.current && (u.current = !0, f.current = Be(Tt(window, "pointerup", p), Tt(window, "pointercancel", c)), r?.(v, P), (m = i.animationState) === null || m === void 0 || m.setActive(F.Tap, !0));
+  }
+  kt(i, "pointerdown", o ? d : void 0), ze(s);
+}
+var mt = function(t) {
+  return function(e) {
+    return t(e), null;
+  };
+}, Gi = {
+  tap: mt(zi),
+  focus: mt(Fi),
+  hover: mt(Xi)
+};
+function Ln(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  var r = e.length;
+  if (r !== t.length)
+    return !1;
+  for (var n = 0; n < r; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+var te = function(t) {
+  return t * 1e3;
+}, lr = {
+  linear: Aa,
+  easeIn: xa,
+  easeInOut: Ta,
+  easeOut: ba,
+  circIn: Pa,
+  circInOut: ya,
+  circOut: ha,
+  backIn: ga,
+  backInOut: pa,
+  backOut: ma,
+  anticipate: da,
+  bounceIn: va,
+  bounceInOut: ca,
+  bounceOut: la
+}, cr = function(t) {
+  if (Array.isArray(t)) {
+    gt(t.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    var e = M(t, 4), r = e[0], n = e[1], a = e[2], i = e[3];
+    return fa(r, n, a, i);
+  } else if (typeof t == "string")
+    return gt(lr[t] !== void 0, "Invalid easing type '" + t + "'"), lr[t];
+  return t;
+}, Wi = function(t) {
+  return Array.isArray(t) && typeof t[0] != "number";
+}, vr = function(t, e) {
+  return t === "zIndex" ? !1 : !!(typeof e == "number" || Array.isArray(e) || typeof e == "string" && // It's animatable if we have a string
+  At.test(e) && // And it contains numbers and/or colors
+  !e.startsWith("url("));
+}, vt = function() {
+  return {
+    type: "spring",
+    stiffness: 500,
+    damping: 25,
+    restDelta: 0.5,
+    restSpeed: 10
+  };
+}, Xt = function(t) {
+  return {
+    type: "spring",
+    stiffness: 550,
+    damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+    restDelta: 0.01,
+    restSpeed: 10
+  };
+}, pe = function() {
+  return {
+    type: "keyframes",
+    ease: "linear",
+    duration: 0.3
+  };
+}, Zi = function(t) {
+  return {
+    type: "keyframes",
+    duration: 0.8,
+    values: t
+  };
+}, dr = {
+  x: vt,
+  y: vt,
+  z: vt,
+  rotate: vt,
+  rotateX: vt,
+  rotateY: vt,
+  rotateZ: vt,
+  scaleX: Xt,
+  scaleY: Xt,
+  scale: Xt,
+  opacity: pe,
+  backgroundColor: pe,
+  color: pe,
+  default: Xt
+}, qi = function(t, e) {
+  var r;
+  return Mt(e) ? r = Zi : r = dr[t] || dr.default, y({ to: e }, r(e));
+}, $i = y(y({}, ln), {
+  // Color props
+  color: G,
+  backgroundColor: G,
+  outlineColor: G,
+  fill: G,
+  stroke: G,
+  // Border props
+  borderColor: G,
+  borderTopColor: G,
+  borderRightColor: G,
+  borderBottomColor: G,
+  borderLeftColor: G,
+  filter: Pe,
+  WebkitFilter: Pe
+}), Ge = function(t) {
+  return $i[t];
+};
+function We(t, e) {
+  var r, n = Ge(t);
+  return n !== Pe && (n = At), (r = n.getAnimatableNone) === null || r === void 0 ? void 0 : r.call(n, e);
+}
+function Ji(t) {
+  t.when, t.delay, t.delayChildren, t.staggerChildren, t.staggerDirection, t.repeat, t.repeatType, t.repeatDelay, t.from;
+  var e = Z(t, ["when", "delay", "delayChildren", "staggerChildren", "staggerDirection", "repeat", "repeatType", "repeatDelay", "from"]);
+  return !!Object.keys(e).length;
+}
+var mr = !1;
+function Qi(t) {
+  var e = t.ease, r = t.times, n = t.yoyo, a = t.flip, i = t.loop, o = Z(t, ["ease", "times", "yoyo", "flip", "loop"]), u = y({}, o);
+  return r && (u.offset = r), o.duration && (u.duration = te(o.duration)), o.repeatDelay && (u.repeatDelay = te(o.repeatDelay)), e && (u.ease = Wi(e) ? e.map(cr) : cr(e)), o.type === "tween" && (u.type = "keyframes"), (n || i || a) && (Zr(!mr, "yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options."), mr = !0, n ? u.repeatType = "reverse" : i ? u.repeatType = "loop" : a && (u.repeatType = "mirror"), u.repeat = i || n || a || o.repeat), o.type !== "spring" && (u.type = "keyframes"), u;
+}
+function ki(t, e) {
+  var r, n = Ze(t, e) || {};
+  return (r = n.delay) !== null && r !== void 0 ? r : 0;
+}
+function to(t) {
+  return Array.isArray(t.to) && t.to[0] === null && (t.to = K([], M(t.to)), t.to[0] = t.from), t;
+}
+function eo(t, e, r) {
+  var n;
+  return Array.isArray(e.to) && ((n = t.duration) !== null && n !== void 0 || (t.duration = 0.8)), to(e), Ji(t) || (t = y(y({}, t), qi(r, e.to))), y(y({}, e), Qi(t));
+}
+function ro(t, e, r, n, a) {
+  var i, o = Ze(n, t), u = (i = o.from) !== null && i !== void 0 ? i : e.get(), f = vr(t, r);
+  u === "none" && f && typeof r == "string" ? u = We(t, r) : pr(u) && typeof r == "string" ? u = gr(r) : !Array.isArray(r) && pr(r) && typeof u == "string" && (r = gr(u));
+  var s = vr(t, u);
+  Zr(s === f, "You are trying to animate " + t + ' from "' + u + '" to "' + r + '". ' + u + " is not an animatable value - to enable this animation set " + u + " to a value animatable to " + r + " via the `style` property.");
+  function l() {
+    var c = {
+      from: u,
+      to: r,
+      velocity: e.getVelocity(),
+      onComplete: a,
+      onUpdate: function(d) {
+        return e.set(d);
+      }
+    };
+    return o.type === "inertia" || o.type === "decay" ? Va(y(y({}, c), o)) : Sa(y(y({}, eo(o, c, t)), { onUpdate: function(d) {
+      var v;
+      c.onUpdate(d), (v = o.onUpdate) === null || v === void 0 || v.call(o, d);
+    }, onComplete: function() {
+      var d;
+      c.onComplete(), (d = o.onComplete) === null || d === void 0 || d.call(o);
+    } }));
+  }
+  function p() {
+    var c;
+    return e.set(r), a(), (c = o?.onComplete) === null || c === void 0 || c.call(o), { stop: function() {
+    } };
+  }
+  return !s || !f || o.type === !1 ? p : l;
+}
+function pr(t) {
+  return t === 0 || typeof t == "string" && parseFloat(t) === 0 && t.indexOf(" ") === -1;
+}
+function gr(t) {
+  return typeof t == "number" ? 0 : We("", t);
+}
+function Ze(t, e) {
+  return t[e] || t.default || t;
+}
+function ee(t, e, r, n) {
+  return n === void 0 && (n = {}), e.start(function(a) {
+    var i, o, u = ro(t, e, r, n, a), f = ki(n, t), s = function() {
+      return o = u();
+    };
+    return f ? i = setTimeout(s, te(f)) : s(), function() {
+      clearTimeout(i), o?.stop();
+    };
+  });
+}
+var no = function(t) {
+  return /^\-?\d*\.?\d+$/.test(t);
+}, wn = 1 / 60 * 1e3, ao = typeof performance < "u" ? function() {
+  return performance.now();
+} : function() {
+  return Date.now();
+}, Rn = typeof window < "u" ? function(t) {
+  return window.requestAnimationFrame(t);
+} : function(t) {
+  return setTimeout(function() {
+    return t(ao());
+  }, wn);
+};
+function io(t) {
+  var e = [], r = [], n = 0, a = !1, i = /* @__PURE__ */ new WeakSet(), o = {
+    schedule: function(u, f, s) {
+      f === void 0 && (f = !1), s === void 0 && (s = !1);
+      var l = s && a, p = l ? e : r;
+      return f && i.add(u), p.indexOf(u) === -1 && (p.push(u), l && a && (n = e.length)), u;
+    },
+    cancel: function(u) {
+      var f = r.indexOf(u);
+      f !== -1 && r.splice(f, 1), i.delete(u);
+    },
+    process: function(u) {
+      var f;
+      if (a = !0, f = [r, e], e = f[0], r = f[1], r.length = 0, n = e.length, n)
+        for (var s = 0; s < n; s++) {
+          var l = e[s];
+          l(u), i.has(l) && (o.schedule(l), t());
+        }
+      a = !1;
+    }
+  };
+  return o;
+}
+var oo = 40, Ae = !0, Ft = !1, Ve = !1, xt = {
+  delta: 0,
+  timestamp: 0
+}, Ht = ["read", "update", "preRender", "render", "postRender"], fe = /* @__PURE__ */ Ht.reduce(function(t, e) {
+  return t[e] = io(function() {
+    return Ft = !0;
+  }), t;
+}, {}), rt = /* @__PURE__ */ Ht.reduce(function(t, e) {
+  var r = fe[e];
+  return t[e] = function(n, a, i) {
+    return a === void 0 && (a = !1), i === void 0 && (i = !1), Ft || so(), r.schedule(n, a, i);
+  }, t;
+}, {}), qt = /* @__PURE__ */ Ht.reduce(function(t, e) {
+  return t[e] = fe[e].cancel, t;
+}, {}), bt = /* @__PURE__ */ Ht.reduce(function(t, e) {
+  return t[e] = function() {
+    return fe[e].process(xt);
+  }, t;
+}, {}), uo = function(t) {
+  return fe[t].process(xt);
+}, Dn = function(t) {
+  Ft = !1, xt.delta = Ae ? wn : Math.max(Math.min(t - xt.timestamp, oo), 1), xt.timestamp = t, Ve = !0, Ht.forEach(uo), Ve = !1, Ft && (Ae = !1, Rn(Dn));
+}, so = function() {
+  Ft = !0, Ae = !0, Ve || Rn(Dn);
+}, Se = function() {
+  return xt;
+};
+function Mn(t, e) {
+  t.indexOf(e) === -1 && t.push(e);
+}
+function Fn(t, e) {
+  var r = t.indexOf(e);
+  r > -1 && t.splice(r, 1);
+}
+var $t = (
+  /** @class */
+  (function() {
+    function t() {
+      this.subscriptions = [];
+    }
+    return t.prototype.add = function(e) {
+      var r = this;
+      return Mn(this.subscriptions, e), function() {
+        return Fn(r.subscriptions, e);
+      };
+    }, t.prototype.notify = function(e, r, n) {
+      var a = this.subscriptions.length;
+      if (a)
+        if (a === 1)
+          this.subscriptions[0](e, r, n);
+        else
+          for (var i = 0; i < a; i++) {
+            var o = this.subscriptions[i];
+            o && o(e, r, n);
+          }
+    }, t.prototype.getSize = function() {
+      return this.subscriptions.length;
+    }, t.prototype.clear = function() {
+      this.subscriptions.length = 0;
+    }, t;
+  })()
+), fo = function(t) {
+  return !isNaN(parseFloat(t));
+}, lo = (
+  /** @class */
+  (function() {
+    function t(e) {
+      var r = this;
+      this.timeDelta = 0, this.lastUpdated = 0, this.updateSubscribers = new $t(), this.velocityUpdateSubscribers = new $t(), this.renderSubscribers = new $t(), this.canTrackVelocity = !1, this.updateAndNotify = function(n, a) {
+        a === void 0 && (a = !0), r.prev = r.current, r.current = n;
+        var i = Se(), o = i.delta, u = i.timestamp;
+        r.lastUpdated !== u && (r.timeDelta = o, r.lastUpdated = u, rt.postRender(r.scheduleVelocityCheck)), r.prev !== r.current && r.updateSubscribers.notify(r.current), r.velocityUpdateSubscribers.getSize() && r.velocityUpdateSubscribers.notify(r.getVelocity()), a && r.renderSubscribers.notify(r.current);
+      }, this.scheduleVelocityCheck = function() {
+        return rt.postRender(r.velocityCheck);
+      }, this.velocityCheck = function(n) {
+        var a = n.timestamp;
+        a !== r.lastUpdated && (r.prev = r.current, r.velocityUpdateSubscribers.notify(r.getVelocity()));
+      }, this.hasAnimated = !1, this.prev = this.current = e, this.canTrackVelocity = fo(this.current);
+    }
+    return t.prototype.onChange = function(e) {
+      return this.updateSubscribers.add(e);
+    }, t.prototype.clearListeners = function() {
+      this.updateSubscribers.clear();
+    }, t.prototype.onRenderRequest = function(e) {
+      return e(this.get()), this.renderSubscribers.add(e);
+    }, t.prototype.attach = function(e) {
+      this.passiveEffect = e;
+    }, t.prototype.set = function(e, r) {
+      r === void 0 && (r = !0), !r || !this.passiveEffect ? this.updateAndNotify(e, r) : this.passiveEffect(e, this.updateAndNotify);
+    }, t.prototype.get = function() {
+      return this.current;
+    }, t.prototype.getPrevious = function() {
+      return this.prev;
+    }, t.prototype.getVelocity = function() {
+      return this.canTrackVelocity ? (
+        // These casts could be avoided if parseFloat would be typed better
+        Ca(parseFloat(this.current) - parseFloat(this.prev), this.timeDelta)
+      ) : 0;
+    }, t.prototype.start = function(e) {
+      var r = this;
+      return this.stop(), new Promise(function(n) {
+        r.hasAnimated = !0, r.stopAnimation = e(n);
+      }).then(function() {
+        return r.clearAnimation();
+      });
+    }, t.prototype.stop = function() {
+      this.stopAnimation && this.stopAnimation(), this.clearAnimation();
+    }, t.prototype.isAnimating = function() {
+      return !!this.stopAnimation;
+    }, t.prototype.clearAnimation = function() {
+      this.stopAnimation = null;
+    }, t.prototype.destroy = function() {
+      this.updateSubscribers.clear(), this.renderSubscribers.clear(), this.stop();
+    }, t;
+  })()
+);
+function pt(t) {
+  return new lo(t);
+}
+var In = function(t) {
+  return function(e) {
+    return e.test(t);
+  };
+}, co = {
+  test: function(t) {
+    return t === "auto";
+  },
+  parse: function(t) {
+    return t;
+  }
+}, Bn = [Ie, V, Ea, at, La, wa, co], zt = function(t) {
+  return Bn.find(In(t));
+}, vo = K(K([], M(Bn)), [G, At]), mo = function(t) {
+  return vo.find(In(t));
+};
+function po(t, e, r) {
+  t.hasValue(e) ? t.getValue(e).set(r) : t.addValue(e, pt(r));
+}
+function go(t, e) {
+  var r = oe(t, e), n = r ? t.makeTargetAnimatable(r, !1) : {}, a = n.transitionEnd, i = a === void 0 ? {} : a;
+  n.transition;
+  var o = Z(n, ["transitionEnd", "transition"]);
+  o = y(y({}, o), i);
+  for (var u in o) {
+    var f = Ci(o[u]);
+    po(t, u, f);
+  }
+}
+function ho(t, e, r) {
+  var n, a, i, o, u = Object.keys(e).filter(function(d) {
+    return !t.hasValue(d);
+  }), f = u.length;
+  if (f)
+    for (var s = 0; s < f; s++) {
+      var l = u[s], p = e[l], c = null;
+      Array.isArray(p) && (c = p[0]), c === null && (c = (a = (n = r[l]) !== null && n !== void 0 ? n : t.readValue(l)) !== null && a !== void 0 ? a : e[l]), c != null && (typeof c == "string" && no(c) ? c = parseFloat(c) : !mo(c) && At.test(p) && (c = We(l, p)), t.addValue(l, pt(c)), (i = (o = r)[l]) !== null && i !== void 0 || (o[l] = c), t.setBaseTarget(l, c));
+    }
+}
+function yo(t, e) {
+  if (e) {
+    var r = e[t] || e.default || e;
+    return r.from;
+  }
+}
+function Po(t, e, r) {
+  var n, a, i = {};
+  for (var o in t)
+    i[o] = (n = yo(o, e)) !== null && n !== void 0 ? n : (a = r.getValue(o)) === null || a === void 0 ? void 0 : a.get();
+  return i;
+}
+function bo(t, e, r) {
+  r === void 0 && (r = {}), t.notifyAnimationStart();
+  var n;
+  if (Array.isArray(e)) {
+    var a = e.map(function(o) {
+      return Ce(t, o, r);
+    });
+    n = Promise.all(a);
+  } else if (typeof e == "string")
+    n = Ce(t, e, r);
+  else {
+    var i = typeof e == "function" ? oe(t, e, r.custom) : e;
+    n = On(t, i, r);
+  }
+  return n.then(function() {
+    return t.notifyAnimationComplete(e);
+  });
+}
+function Ce(t, e, r) {
+  var n;
+  r === void 0 && (r = {});
+  var a = oe(t, e, r.custom), i = (a || {}).transition, o = i === void 0 ? t.getDefaultTransition() || {} : i;
+  r.transitionOverride && (o = r.transitionOverride);
+  var u = a ? function() {
+    return On(t, a, r);
+  } : function() {
+    return Promise.resolve();
+  }, f = !((n = t.variantChildren) === null || n === void 0) && n.size ? function(d) {
+    d === void 0 && (d = 0);
+    var v = o.delayChildren, P = v === void 0 ? 0 : v, m = o.staggerChildren, h = o.staggerDirection;
+    return To(t, e, P + d, m, h, r);
+  } : function() {
+    return Promise.resolve();
+  }, s = o.when;
+  if (s) {
+    var l = M(s === "beforeChildren" ? [u, f] : [f, u], 2), p = l[0], c = l[1];
+    return p().then(c);
+  } else
+    return Promise.all([u(), f(r.delay)]);
+}
+function On(t, e, r) {
+  var n, a = r === void 0 ? {} : r, i = a.delay, o = i === void 0 ? 0 : i, u = a.transitionOverride, f = a.type, s = t.makeTargetAnimatable(e), l = s.transition, p = l === void 0 ? t.getDefaultTransition() : l, c = s.transitionEnd, d = Z(s, ["transition", "transitionEnd"]);
+  u && (p = u);
+  var v = [], P = f && ((n = t.animationState) === null || n === void 0 ? void 0 : n.getState()[f]);
+  for (var m in d) {
+    var h = t.getValue(m), A = d[m];
+    if (!(!h || A === void 0 || P && Ao(P, m))) {
+      var L = ee(m, h, A, y({ delay: o }, p));
+      v.push(L);
+    }
+  }
+  return Promise.all(v).then(function() {
+    c && go(t, c);
+  });
+}
+function To(t, e, r, n, a, i) {
+  r === void 0 && (r = 0), n === void 0 && (n = 0), a === void 0 && (a = 1);
+  var o = [], u = (t.variantChildren.size - 1) * n, f = a === 1 ? function(s) {
+    return s === void 0 && (s = 0), s * n;
+  } : function(s) {
+    return s === void 0 && (s = 0), u - s * n;
+  };
+  return Array.from(t.variantChildren).sort(xo).forEach(function(s, l) {
+    o.push(Ce(s, e, y(y({}, i), { delay: r + f(l) })).then(function() {
+      return s.notifyAnimationComplete(e);
+    }));
+  }), Promise.all(o);
+}
+function xo(t, e) {
+  return t.sortNodePosition(e);
+}
+function Ao(t, e) {
+  var r = t.protectedKeys, n = t.needsAnimating, a = r.hasOwnProperty(e) && n[e] !== !0;
+  return n[e] = !1, a;
+}
+var qe = [
+  F.Animate,
+  F.Hover,
+  F.Tap,
+  F.Drag,
+  F.Focus,
+  F.Exit
+], Vo = K([], M(qe)).reverse(), So = qe.length;
+function Co(t) {
+  return function(e) {
+    return Promise.all(e.map(function(r) {
+      var n = r.animation, a = r.options;
+      return bo(t, n, a);
+    }));
+  };
+}
+function Eo(t) {
+  var e = Co(t), r = wo(), n = {}, a = !0, i = function(l, p) {
+    var c = oe(t, p);
+    if (c) {
+      c.transition;
+      var d = c.transitionEnd, v = Z(c, ["transition", "transitionEnd"]);
+      l = y(y(y({}, l), v), d);
+    }
+    return l;
+  };
+  function o(l) {
+    return n[l] !== void 0;
+  }
+  function u(l) {
+    e = l(t);
+  }
+  function f(l, p) {
+    for (var c, d = t.getProps(), v = t.getVariantContext(!0) || {}, P = [], m = /* @__PURE__ */ new Set(), h = {}, A = 1 / 0, L = function(w) {
+      var E = Vo[w], S = r[E], I = (c = d[E]) !== null && c !== void 0 ? c : v[E], _ = W(I), k = E === p ? S.isActive : null;
+      k === !1 && (A = w);
+      var X = I === v[E] && I !== d[E] && _;
+      if (X && a && t.manuallyAnimateOnMount && (X = !1), S.protectedKeys = y({}, h), // If it isn't active and hasn't *just* been set as inactive
+      !S.isActive && k === null || // If we didn't and don't have any defined prop for this animation type
+      !I && !S.prevProp || // Or if the prop doesn't define an animation
+      Ke(I) || typeof I == "boolean")
+        return "continue";
+      var j = Lo(S.prevProp, I) || // If we're making this variant active, we want to always make it active
+      E === p && S.isActive && !X && _ || // If we removed a higher-priority variant (i is in reverse order)
+      w > A && _, ut = Array.isArray(I) ? I : [I], tt = ut.reduce(i, {});
+      k === !1 && (tt = {});
+      var nt = S.prevResolvedValues, st = nt === void 0 ? {} : nt, _t = y(y({}, st), tt), ft = function(ct) {
+        j = !0, m.delete(ct), S.needsAnimating[ct] = !0;
+      };
+      for (var Y in _t) {
+        var q = tt[Y], lt = st[Y];
+        h.hasOwnProperty(Y) || (q !== lt ? Mt(q) && Mt(lt) ? Ln(q, lt) ? S.protectedKeys[Y] = !0 : ft(Y) : q !== void 0 ? ft(Y) : m.add(Y) : q !== void 0 && m.has(Y) ? ft(Y) : S.protectedKeys[Y] = !0);
+      }
+      S.prevProp = I, S.prevResolvedValues = tt, S.isActive && (h = y(y({}, h), tt)), a && t.blockInitialAnimation && (j = !1), j && !X && P.push.apply(P, K([], M(ut.map(function(ct) {
+        return {
+          animation: ct,
+          options: y({ type: E }, l)
+        };
+      }))));
+    }, D = 0; D < So; D++)
+      L(D);
+    if (n = y({}, h), m.size) {
+      var C = {};
+      m.forEach(function(w) {
+        var E = t.getBaseTarget(w);
+        E !== void 0 && (C[w] = E);
+      }), P.push({ animation: C });
+    }
+    var x = !!P.length;
+    return a && d.initial === !1 && !t.manuallyAnimateOnMount && (x = !1), a = !1, x ? e(P) : Promise.resolve();
+  }
+  function s(l, p, c) {
+    var d;
+    return r[l].isActive === p ? Promise.resolve() : ((d = t.variantChildren) === null || d === void 0 || d.forEach(function(v) {
+      var P;
+      return (P = v.animationState) === null || P === void 0 ? void 0 : P.setActive(l, p);
+    }), r[l].isActive = p, f(c, l));
+  }
+  return {
+    isAnimated: o,
+    animateChanges: f,
+    setActive: s,
+    setAnimateFunction: u,
+    getState: function() {
+      return r;
+    }
+  };
+}
+function Lo(t, e) {
+  return typeof e == "string" ? e !== t : nn(e) ? !Ln(e, t) : !1;
+}
+function yt(t) {
+  return t === void 0 && (t = !1), {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function wo() {
+  var t;
+  return t = {}, t[F.Animate] = yt(!0), t[F.Hover] = yt(), t[F.Tap] = yt(), t[F.Drag] = yt(), t[F.Focus] = yt(), t[F.Exit] = yt(), t;
+}
+var Ro = {
+  animation: mt(function(t) {
+    var e = t.visualElement, r = t.animate;
+    e.animationState || (e.animationState = Eo(e)), Ke(r) && Q(function() {
+      return r.subscribe(e);
+    }, [r]);
+  }),
+  exit: mt(function(t) {
+    var e = t.custom, r = t.visualElement, n = M(en(), 2), a = n[0], i = n[1], o = O(St);
+    Q(function() {
+      var u, f, s = (u = r.animationState) === null || u === void 0 ? void 0 : u.setActive(F.Exit, !a, { custom: (f = o?.custom) !== null && f !== void 0 ? f : e });
+      !a && s?.then(i);
+    }, [a]);
+  })
+}, jn = (
+  /** @class */
+  (function() {
+    function t(e, r, n) {
+      var a = this, i = n === void 0 ? {} : n, o = i.transformPagePoint;
+      if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.updatePoint = function() {
+        if (a.lastMoveEvent && a.lastMoveEventInfo) {
+          var c = he(a.lastMoveEventInfo, a.history), d = a.startEvent !== null, v = qr(c.offset, { x: 0, y: 0 }) >= 3;
+          if (!(!d && !v)) {
+            var P = c.point, m = Se().timestamp;
+            a.history.push(y(y({}, P), { timestamp: m }));
+            var h = a.handlers, A = h.onStart, L = h.onMove;
+            d || (A && A(a.lastMoveEvent, c), a.startEvent = a.lastMoveEvent), L && L(a.lastMoveEvent, c);
+          }
+        }
+      }, this.handlePointerMove = function(c, d) {
+        if (a.lastMoveEvent = c, a.lastMoveEventInfo = ge(d, a.transformPagePoint), bn(c) && c.buttons === 0) {
+          a.handlePointerUp(c, d);
+          return;
+        }
+        rt.update(a.updatePoint, !0);
+      }, this.handlePointerUp = function(c, d) {
+        a.end();
+        var v = a.handlers, P = v.onEnd, m = v.onSessionEnd, h = he(ge(d, a.transformPagePoint), a.history);
+        a.startEvent && P && P(c, h), m && m(c, h);
+      }, !(Tn(e) && e.touches.length > 1)) {
+        this.handlers = r, this.transformPagePoint = o;
+        var u = Xe(e), f = ge(u, this.transformPagePoint), s = f.point, l = Se().timestamp;
+        this.history = [y(y({}, s), { timestamp: l })];
+        var p = r.onSessionStart;
+        p && p(e, he(f, this.history)), this.removeListeners = Be(Tt(window, "pointermove", this.handlePointerMove), Tt(window, "pointerup", this.handlePointerUp), Tt(window, "pointercancel", this.handlePointerUp));
+      }
+    }
+    return t.prototype.updateHandlers = function(e) {
+      this.handlers = e;
+    }, t.prototype.end = function() {
+      this.removeListeners && this.removeListeners(), qt.update(this.updatePoint);
+    }, t;
+  })()
+);
+function ge(t, e) {
+  return e ? { point: e(t.point) } : t;
+}
+function hr(t, e) {
+  return { x: t.x - e.x, y: t.y - e.y };
+}
+function he(t, e) {
+  var r = t.point;
+  return {
+    point: r,
+    delta: hr(r, Hn(e)),
+    offset: hr(r, Do(e)),
+    velocity: Mo(e, 0.1)
+  };
+}
+function Do(t) {
+  return t[0];
+}
+function Hn(t) {
+  return t[t.length - 1];
+}
+function Mo(t, e) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  for (var r = t.length - 1, n = null, a = Hn(t); r >= 0 && (n = t[r], !(a.timestamp - n.timestamp > te(e))); )
+    r--;
+  if (!n)
+    return { x: 0, y: 0 };
+  var i = (a.timestamp - n.timestamp) / 1e3;
+  if (i === 0)
+    return { x: 0, y: 0 };
+  var o = {
+    x: (a.x - n.x) / i,
+    y: (a.y - n.y) / i
+  };
+  return o.x === 1 / 0 && (o.x = 0), o.y === 1 / 0 && (o.y = 0), o;
+}
+function Fo(t) {
+  return t;
+}
+function _n(t) {
+  var e = t.top, r = t.left, n = t.right, a = t.bottom;
+  return {
+    x: { min: r, max: n },
+    y: { min: e, max: a }
+  };
+}
+function Io(t) {
+  var e = t.x, r = t.y;
+  return {
+    top: r.min,
+    bottom: r.max,
+    left: e.min,
+    right: e.max
+  };
+}
+function Bo(t, e) {
+  var r = t.top, n = t.left, a = t.bottom, i = t.right;
+  e === void 0 && (e = Fo);
+  var o = e({ x: n, y: r }), u = e({ x: i, y: a });
+  return {
+    top: o.y,
+    left: o.x,
+    bottom: u.y,
+    right: u.x
+  };
+}
+function ot() {
+  return { x: { min: 0, max: 1 }, y: { min: 0, max: 1 } };
+}
+function Oo(t) {
+  return {
+    x: y({}, t.x),
+    y: y({}, t.y)
+  };
+}
+var yr = {
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+};
+function Pr() {
+  return {
+    x: y({}, yr),
+    y: y({}, yr)
+  };
+}
+function N(t) {
+  return [t("x"), t("y")];
+}
+function Un(t, e, r) {
+  var n = e.min, a = e.max;
+  return n !== void 0 && t < n ? t = r ? J(n, t, r.min) : Math.max(t, n) : a !== void 0 && t > a && (t = r ? J(a, t, r.max) : Math.min(t, a)), t;
+}
+function jo(t, e, r, n, a) {
+  var i = t - e * r;
+  return n ? Un(i, n, a) : i;
+}
+function br(t, e, r) {
+  return {
+    min: e !== void 0 ? t.min + e : void 0,
+    max: r !== void 0 ? t.max + r - (t.max - t.min) : void 0
+  };
+}
+function Ho(t, e) {
+  var r = e.top, n = e.left, a = e.bottom, i = e.right;
+  return {
+    x: br(t.x, n, i),
+    y: br(t.y, r, a)
+  };
+}
+function Tr(t, e) {
+  var r, n = e.min - t.min, a = e.max - t.max;
+  return e.max - e.min < t.max - t.min && (r = M([a, n], 2), n = r[0], a = r[1]), {
+    min: t.min + n,
+    max: t.min + a
+  };
+}
+function _o(t, e) {
+  return {
+    x: Tr(t.x, e.x),
+    y: Tr(t.y, e.y)
+  };
+}
+function Uo(t, e, r) {
+  var n = t.max - t.min, a = J(e.min, e.max - n, r);
+  return { min: a, max: a + n };
+}
+function No(t, e) {
+  var r = {};
+  return e.min !== void 0 && (r.min = e.min - t.min), e.max !== void 0 && (r.max = e.max - t.min), r;
+}
+var Nn = 0.35;
+function Ko(t) {
+  return t === !1 ? t = 0 : t === !0 && (t = Nn), {
+    x: xr(t, "left", "right"),
+    y: xr(t, "top", "bottom")
+  };
+}
+function xr(t, e, r) {
+  return {
+    min: Ar(t, e),
+    max: Ar(t, r)
+  };
+}
+function Ar(t, e) {
+  var r;
+  return typeof t == "number" ? t : (r = t[e]) !== null && r !== void 0 ? r : 0;
+}
+function Kn(t, e) {
+  var r = t.getBoundingClientRect();
+  return _n(Bo(r, e));
+}
+var Yo = function(t) {
+  return Ra(0, 1, t);
+};
+function Vr(t, e, r) {
+  return e === void 0 && (e = 0), r === void 0 && (r = 0.01), qr(t, e) < r;
+}
+function It(t) {
+  return t.max - t.min;
+}
+function Xo(t, e) {
+  var r = 0.5, n = It(t), a = It(e);
+  return a > n ? r = be(e.min, e.max - n, t.min) : n > a && (r = be(t.min, t.max - a, e.min)), Yo(r);
+}
+function Sr(t, e, r, n) {
+  n === void 0 && (n = 0.5), t.origin = n, t.originPoint = J(e.min, e.max, t.origin), t.scale = It(r) / It(e), Vr(t.scale, 1, 1e-4) && (t.scale = 1), t.translate = J(r.min, r.max, t.origin) - t.originPoint, Vr(t.translate) && (t.translate = 0);
+}
+function Yn(t, e, r, n) {
+  Sr(t.x, e.x, r.x, Cr(n.originX)), Sr(t.y, e.y, r.y, Cr(n.originY));
+}
+function Cr(t) {
+  return typeof t == "number" ? t : 0.5;
+}
+function Er(t, e, r) {
+  t.min = r.min + e.min, t.max = t.min + It(e);
+}
+function zo(t, e) {
+  Er(t.target.x, t.relativeTarget.x, e.target.x), Er(t.target.y, t.relativeTarget.y, e.target.y);
+}
+var $e = function(t, e) {
+  return t.depth - e.depth;
+};
+function Xn(t) {
+  var e = t.projection.isEnabled;
+  return e || t.shouldResetTransform();
+}
+function re(t, e) {
+  e === void 0 && (e = []);
+  var r = t.parent;
+  return r && re(r, e), Xn(t) && e.push(t), e;
+}
+function Go(t) {
+  var e = [], r = function(n) {
+    Xn(n) && e.push(n), n.children.forEach(r);
+  };
+  return t.children.forEach(r), e.sort($e);
+}
+function Jt(t) {
+  if (!t.shouldResetTransform()) {
+    var e = t.getLayoutState();
+    t.notifyBeforeLayoutMeasure(e.layout), e.isHydrated = !0, e.layout = t.measureViewportBox(), e.layoutCorrected = Oo(e.layout), t.notifyLayoutMeasure(e.layout, t.prevViewportBox || e.layout), rt.update(function() {
+      return t.rebaseProjectionTarget();
+    });
+  }
+}
+function Wo(t) {
+  t.shouldResetTransform() || (t.prevViewportBox = t.measureViewportBox(!1), t.rebaseProjectionTarget(!1, t.prevViewportBox));
+}
+function Zo(t, e, r, n) {
+  t.min = J(e.min, r.min, n), t.max = J(e.max, r.max, n);
+}
+function Lr(t, e) {
+  return {
+    min: e.min - t.min,
+    max: e.max - t.min
+  };
+}
+function Vt(t, e) {
+  return {
+    x: Lr(t.x, e.x),
+    y: Lr(t.y, e.y)
+  };
+}
+function qo(t, e) {
+  var r = t.getLayoutId(), n = e.getLayoutId();
+  return r !== n || n === void 0 && t !== e;
+}
+function zn(t) {
+  var e = t.getProps(), r = e.drag, n = e._dragX;
+  return r && !n;
+}
+function wr(t, e) {
+  t.min = e.min, t.max = e.max;
+}
+function $o(t, e) {
+  wr(t.x, e.x), wr(t.y, e.y);
+}
+function ne(t, e, r) {
+  var n = t - r, a = e * n;
+  return r + a;
+}
+function Rr(t, e, r, n, a) {
+  return a !== void 0 && (t = ne(t, a, n)), ne(t, r, n) + e;
+}
+function Ee(t, e, r, n, a) {
+  e === void 0 && (e = 0), r === void 0 && (r = 1), t.min = Rr(t.min, e, r, n, a), t.max = Rr(t.max, e, r, n, a);
+}
+function Jo(t, e) {
+  var r = e.x, n = e.y;
+  Ee(t.x, r.translate, r.scale, r.originPoint), Ee(t.y, n.translate, n.scale, n.originPoint);
+}
+function Dr(t, e, r, n) {
+  var a = M(n, 3), i = a[0], o = a[1], u = a[2];
+  t.min = e.min, t.max = e.max;
+  var f = r[u] !== void 0 ? r[u] : 0.5, s = J(e.min, e.max, f);
+  Ee(t, r[i], r[o], s, r.scale);
+}
+var Gn = ["x", "scaleX", "originX"], Wn = ["y", "scaleY", "originY"];
+function Le(t, e, r) {
+  Dr(t.x, e.x, r, Gn), Dr(t.y, e.y, r, Wn);
+}
+function Mr(t, e, r, n, a) {
+  return t -= e, t = ne(t, 1 / r, n), a !== void 0 && (t = ne(t, 1 / a, n)), t;
+}
+function Qo(t, e, r, n, a) {
+  e === void 0 && (e = 0), r === void 0 && (r = 1), n === void 0 && (n = 0.5);
+  var i = J(t.min, t.max, n) - e;
+  t.min = Mr(t.min, e, r, i, a), t.max = Mr(t.max, e, r, i, a);
+}
+function Fr(t, e, r) {
+  var n = M(r, 3), a = n[0], i = n[1], o = n[2];
+  Qo(t, e[a], e[i], e[o], e.scale);
+}
+function Zn(t, e) {
+  Fr(t.x, e, Gn), Fr(t.y, e, Wn);
+}
+function ko(t, e, r) {
+  var n = r.length;
+  if (n) {
+    e.x = e.y = 1;
+    for (var a, i, o = 0; o < n; o++)
+      a = r[o], i = a.getLayoutState().delta, e.x *= i.x.scale, e.y *= i.y.scale, Jo(t, i), zn(a) && Le(t, t, a.getLatestValues());
+  }
+}
+function tu(t, e) {
+  e === void 0 && (e = !0);
+  var r = t.getProjectionParent();
+  if (!r)
+    return !1;
+  var n;
+  return e ? (n = Vt(r.projection.target, t.projection.target), Zn(n, r.getLatestValues())) : n = Vt(r.getLayoutState().layout, t.getLayoutState().layout), N(function(a) {
+    return t.setProjectionTargetAxis(a, n[a].min, n[a].max, !0);
+  }), !0;
+}
+var Lt = /* @__PURE__ */ new Set();
+function Ir(t, e, r) {
+  t[r] || (t[r] = []), t[r].push(e);
+}
+function we(t) {
+  return Lt.add(t), function() {
+    return Lt.delete(t);
+  };
+}
+function Re() {
+  if (Lt.size) {
+    var t = 0, e = [[]], r = [], n = function(u) {
+      return Ir(e, u, t);
+    }, a = function(u) {
+      Ir(r, u, t), t++;
+    };
+    Lt.forEach(function(u) {
+      u(n, a), t = 0;
+    }), Lt.clear();
+    for (var i = r.length, o = 0; o <= i; o++)
+      e[o] && e[o].forEach(Br), r[o] && r[o].forEach(Br);
+  }
+}
+var Br = function(t) {
+  return t();
+}, eu = /* @__PURE__ */ new WeakMap(), Or, ru = (
+  /** @class */
+  (function() {
+    function t(e) {
+      var r = e.visualElement;
+      this.isDragging = !1, this.currentDirection = null, this.constraints = !1, this.elastic = ot(), this.props = {}, this.hasMutatedConstraints = !1, this.cursorProgress = {
+        x: 0.5,
+        y: 0.5
+      }, this.originPoint = {}, this.openGlobalLock = null, this.panSession = null, this.visualElement = r, this.visualElement.enableLayoutProjection(), eu.set(r, this);
+    }
+    return t.prototype.start = function(e, r) {
+      var n = this, a = r === void 0 ? {} : r, i = a.snapToCursor, o = i === void 0 ? !1 : i, u = a.cursorProgress, f = function(d) {
+        var v;
+        n.stopMotion();
+        var P = Hi(d).point;
+        (v = n.cancelLayout) === null || v === void 0 || v.call(n), n.cancelLayout = we(function(m, h) {
+          var A = re(n.visualElement), L = Go(n.visualElement), D = K(K([], M(A)), M(L)), C = !1;
+          n.isLayoutDrag() && n.visualElement.lockProjectionTarget(), h(function() {
+            D.forEach(function(x) {
+              return x.resetTransform();
+            });
+          }), m(function() {
+            Jt(n.visualElement), L.forEach(Jt);
+          }), h(function() {
+            D.forEach(function(x) {
+              return x.restoreTransform();
+            }), o && (C = n.snapToCursor(P));
+          }), m(function() {
+            var x = !!(n.getAxisMotionValue("x") && !n.isExternalDrag());
+            x || n.visualElement.rebaseProjectionTarget(!0, n.visualElement.measureViewportBox(!1)), n.visualElement.scheduleUpdateLayoutProjection();
+            var w = n.visualElement.projection;
+            N(function(E) {
+              if (!C) {
+                var S = w.target[E], I = S.min, _ = S.max;
+                n.cursorProgress[E] = u ? u[E] : be(I, _, P[E]);
+              }
+              var k = n.getAxisMotionValue(E);
+              k && (n.originPoint[E] = k.get());
+            });
+          }), h(function() {
+            bt.update(), bt.preRender(), bt.render(), bt.postRender();
+          }), m(function() {
+            return n.resolveDragConstraints();
+          });
+        });
+      }, s = function(d, v) {
+        var P, m, h, A = n.props, L = A.drag, D = A.dragPropagation;
+        L && !D && (n.openGlobalLock && n.openGlobalLock(), n.openGlobalLock = Sn(L), !n.openGlobalLock) || (Re(), n.isDragging = !0, n.currentDirection = null, (m = (P = n.props).onDragStart) === null || m === void 0 || m.call(P, d, v), (h = n.visualElement.animationState) === null || h === void 0 || h.setActive(F.Drag, !0));
+      }, l = function(d, v) {
+        var P, m, h, A, L = n.props, D = L.dragPropagation, C = L.dragDirectionLock;
+        if (!(!D && !n.openGlobalLock)) {
+          var x = v.offset;
+          if (C && n.currentDirection === null) {
+            n.currentDirection = nu(x), n.currentDirection !== null && ((m = (P = n.props).onDirectionLock) === null || m === void 0 || m.call(P, n.currentDirection));
+            return;
+          }
+          n.updateAxis("x", v.point, x), n.updateAxis("y", v.point, x), (A = (h = n.props).onDrag) === null || A === void 0 || A.call(h, d, v), Or = d;
+        }
+      }, p = function(d, v) {
+        return n.stop(d, v);
+      }, c = this.props.transformPagePoint;
+      this.panSession = new jn(e, {
+        onSessionStart: f,
+        onStart: s,
+        onMove: l,
+        onSessionEnd: p
+      }, { transformPagePoint: c });
+    }, t.prototype.resolveDragConstraints = function() {
+      var e = this, r = this.props, n = r.dragConstraints, a = r.dragElastic, i = this.visualElement.getLayoutState().layoutCorrected;
+      n ? this.constraints = Te(n) ? this.resolveRefConstraints(i, n) : Ho(i, n) : this.constraints = !1, this.elastic = Ko(a), this.constraints && !this.hasMutatedConstraints && N(function(o) {
+        e.getAxisMotionValue(o) && (e.constraints[o] = No(i[o], e.constraints[o]));
+      });
+    }, t.prototype.resolveRefConstraints = function(e, r) {
+      var n = this.props, a = n.onMeasureDragConstraints, i = n.transformPagePoint, o = r.current;
+      gt(o !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop."), this.constraintsBox = Kn(o, i);
+      var u = _o(e, this.constraintsBox);
+      if (a) {
+        var f = a(Io(u));
+        this.hasMutatedConstraints = !!f, f && (u = _n(f));
+      }
+      return u;
+    }, t.prototype.cancelDrag = function() {
+      var e, r;
+      this.visualElement.unlockProjectionTarget(), (e = this.cancelLayout) === null || e === void 0 || e.call(this), this.isDragging = !1, this.panSession && this.panSession.end(), this.panSession = null, !this.props.dragPropagation && this.openGlobalLock && (this.openGlobalLock(), this.openGlobalLock = null), (r = this.visualElement.animationState) === null || r === void 0 || r.setActive(F.Drag, !1);
+    }, t.prototype.stop = function(e, r) {
+      var n, a, i;
+      (n = this.panSession) === null || n === void 0 || n.end(), this.panSession = null;
+      var o = this.isDragging;
+      if (this.cancelDrag(), !!o) {
+        var u = r.velocity;
+        this.animateDragEnd(u), (i = (a = this.props).onDragEnd) === null || i === void 0 || i.call(a, e, r);
+      }
+    }, t.prototype.snapToCursor = function(e) {
+      var r = this;
+      return N(function(n) {
+        var a = r.props.drag;
+        if (Gt(n, a, r.currentDirection)) {
+          var i = r.getAxisMotionValue(n);
+          if (i) {
+            var o = r.visualElement.getLayoutState().layout, u = o[n].max - o[n].min, f = o[n].min + u / 2, s = e[n] - f;
+            r.originPoint[n] = e[n], i.set(s);
+          } else
+            return r.cursorProgress[n] = 0.5, !0;
+        }
+      }).includes(!0);
+    }, t.prototype.updateAxis = function(e, r, n) {
+      var a = this.props.drag;
+      if (Gt(e, a, this.currentDirection))
+        return this.getAxisMotionValue(e) ? this.updateAxisMotionValue(e, n) : this.updateVisualElementAxis(e, r);
+    }, t.prototype.updateAxisMotionValue = function(e, r) {
+      var n = this.getAxisMotionValue(e);
+      if (!(!r || !n)) {
+        var a = this.originPoint[e] + r[e], i = this.constraints ? Un(a, this.constraints[e], this.elastic[e]) : a;
+        n.set(i);
+      }
+    }, t.prototype.updateVisualElementAxis = function(e, r) {
+      var n, a = this.visualElement.getLayoutState().layout[e], i = a.max - a.min, o = this.cursorProgress[e], u = jo(r[e], i, o, (n = this.constraints) === null || n === void 0 ? void 0 : n[e], this.elastic[e]);
+      this.visualElement.setProjectionTargetAxis(e, u, u + i);
+    }, t.prototype.setProps = function(e) {
+      var r = e.drag, n = r === void 0 ? !1 : r, a = e.dragDirectionLock, i = a === void 0 ? !1 : a, o = e.dragPropagation, u = o === void 0 ? !1 : o, f = e.dragConstraints, s = f === void 0 ? !1 : f, l = e.dragElastic, p = l === void 0 ? Nn : l, c = e.dragMomentum, d = c === void 0 ? !0 : c, v = Z(e, ["drag", "dragDirectionLock", "dragPropagation", "dragConstraints", "dragElastic", "dragMomentum"]);
+      this.props = y({
+        drag: n,
+        dragDirectionLock: i,
+        dragPropagation: u,
+        dragConstraints: s,
+        dragElastic: p,
+        dragMomentum: d
+      }, v);
+    }, t.prototype.getAxisMotionValue = function(e) {
+      var r = this.props, n = r.layout, a = r.layoutId, i = "_drag" + e.toUpperCase();
+      if (this.props[i])
+        return this.props[i];
+      if (!n && a === void 0)
+        return this.visualElement.getValue(e, 0);
+    }, t.prototype.isLayoutDrag = function() {
+      return !this.getAxisMotionValue("x");
+    }, t.prototype.isExternalDrag = function() {
+      var e = this.props, r = e._dragX, n = e._dragY;
+      return r || n;
+    }, t.prototype.animateDragEnd = function(e) {
+      var r = this, n = this.props, a = n.drag, i = n.dragMomentum, o = n.dragElastic, u = n.dragTransition, f = tu(this.visualElement, this.isLayoutDrag() && !this.isExternalDrag()), s = this.constraints || {};
+      if (f && Object.keys(s).length && this.isLayoutDrag()) {
+        var l = this.visualElement.getProjectionParent();
+        if (l) {
+          var p = Vt(l.projection.targetFinal, s);
+          N(function(d) {
+            var v = p[d], P = v.min, m = v.max;
+            s[d] = {
+              min: isNaN(P) ? void 0 : P,
+              max: isNaN(m) ? void 0 : m
+            };
+          });
+        }
+      }
+      var c = N(function(d) {
+        var v;
+        if (Gt(d, a, r.currentDirection)) {
+          var P = (v = s?.[d]) !== null && v !== void 0 ? v : {}, m = o ? 200 : 1e6, h = o ? 40 : 1e7, A = y(y({
+            type: "inertia",
+            velocity: i ? e[d] : 0,
+            bounceStiffness: m,
+            bounceDamping: h,
+            timeConstant: 750,
+            restDelta: 1,
+            restSpeed: 10
+          }, u), P);
+          return r.getAxisMotionValue(d) ? r.startAxisValueAnimation(d, A) : r.visualElement.startLayoutAnimation(d, A, f);
+        }
+      });
+      return Promise.all(c).then(function() {
+        var d, v;
+        (v = (d = r.props).onDragTransitionEnd) === null || v === void 0 || v.call(d);
+      });
+    }, t.prototype.stopMotion = function() {
+      var e = this;
+      N(function(r) {
+        var n = e.getAxisMotionValue(r);
+        n ? n.stop() : e.visualElement.stopLayoutAnimation();
+      });
+    }, t.prototype.startAxisValueAnimation = function(e, r) {
+      var n = this.getAxisMotionValue(e);
+      if (n) {
+        var a = n.get();
+        return n.set(a), n.set(a), ee(e, n, 0, r);
+      }
+    }, t.prototype.scalePoint = function() {
+      var e = this, r = this.props, n = r.drag, a = r.dragConstraints;
+      if (!(!Te(a) || !this.constraintsBox)) {
+        this.stopMotion();
+        var i = { x: 0, y: 0 };
+        N(function(o) {
+          i[o] = Xo(e.visualElement.projection.target[o], e.constraintsBox[o]);
+        }), this.updateConstraints(function() {
+          N(function(o) {
+            if (Gt(o, n, null)) {
+              var u = Uo(e.visualElement.projection.target[o], e.constraintsBox[o], i[o]), f = u.min, s = u.max;
+              e.visualElement.setProjectionTargetAxis(o, f, s);
+            }
+          });
+        }), setTimeout(Re, 1);
+      }
+    }, t.prototype.updateConstraints = function(e) {
+      var r = this;
+      this.cancelLayout = we(function(n, a) {
+        var i = re(r.visualElement);
+        a(function() {
+          return i.forEach(function(o) {
+            return o.resetTransform();
+          });
+        }), n(function() {
+          return Jt(r.visualElement);
+        }), a(function() {
+          return i.forEach(function(o) {
+            return o.restoreTransform();
+          });
+        }), n(function() {
+          r.resolveDragConstraints();
+        }), e && a(e);
+      });
+    }, t.prototype.mount = function(e) {
+      var r = this, n = e.getInstance(), a = Tt(n, "pointerdown", function(f) {
+        var s = r.props, l = s.drag, p = s.dragListener, c = p === void 0 ? !0 : p;
+        l && c && r.start(f);
+      }), i = Ye(window, "resize", function() {
+        r.scalePoint();
+      }), o = e.onLayoutUpdate(function() {
+        r.isDragging && r.resolveDragConstraints();
+      }), u = e.prevDragCursor;
+      return u && this.start(Or, { cursorProgress: u }), function() {
+        a?.(), i?.(), o?.(), r.cancelDrag();
+      };
+    }, t;
+  })()
+);
+function Gt(t, e, r) {
+  return (e === !0 || e === t) && (r === null || r === t);
+}
+function nu(t, e) {
+  e === void 0 && (e = 10);
+  var r = null;
+  return Math.abs(t.y) > e ? r = "y" : Math.abs(t.x) > e && (r = "x"), r;
+}
+function au(t) {
+  var e = t.dragControls, r = t.visualElement, n = O(ae).transformPagePoint, a = Rt(function() {
+    return new ru({
+      visualElement: r
+    });
+  });
+  a.setProps(y(y({}, t), { transformPagePoint: n })), Q(function() {
+    return e && e.subscribe(a);
+  }, [a]), Q(function() {
+    return a.mount(r);
+  }, []);
+}
+function iu(t) {
+  var e = t.onPan, r = t.onPanStart, n = t.onPanEnd, a = t.onPanSessionStart, i = t.visualElement, o = e || r || n || a, u = $(null), f = O(ae).transformPagePoint, s = {
+    onSessionStart: a,
+    onStart: r,
+    onMove: e,
+    onEnd: function(p, c) {
+      u.current = null, n && n(p, c);
+    }
+  };
+  Q(function() {
+    u.current !== null && u.current.updateHandlers(s);
+  });
+  function l(p) {
+    u.current = new jn(p, s, {
+      transformPagePoint: f
+    });
+  }
+  kt(i, "pointerdown", o && l), ze(function() {
+    return u.current && u.current.end();
+  });
+}
+var ou = {
+  pan: mt(iu),
+  drag: mt(au)
+}, Bt;
+(function(t) {
+  t[t.Entering = 0] = "Entering", t[t.Present = 1] = "Present", t[t.Exiting = 2] = "Exiting";
+})(Bt || (Bt = {}));
+var De;
+(function(t) {
+  t[t.Hide = 0] = "Hide", t[t.Show = 1] = "Show";
+})(De || (De = {}));
+function Me(t) {
+  return typeof t == "string" && t.startsWith("var(--");
+}
+var qn = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;
+function uu(t) {
+  var e = qn.exec(t);
+  if (!e)
+    return [,];
+  var r = M(e, 3), n = r[1], a = r[2];
+  return [n, a];
+}
+var su = 4;
+function Fe(t, e, r) {
+  r === void 0 && (r = 1), gt(r <= su, 'Max CSS variable fallback depth detected in property "' + t + '". This may indicate a circular fallback dependency.');
+  var n = M(uu(t), 2), a = n[0], i = n[1];
+  if (a) {
+    var o = window.getComputedStyle(e).getPropertyValue(a);
+    return o ? o.trim() : Me(i) ? Fe(i, e, r + 1) : i;
+  }
+}
+function fu(t, e, r) {
+  var n, a = Z(e, []), i = t.getInstance();
+  if (!(i instanceof HTMLElement))
+    return { target: a, transitionEnd: r };
+  r && (r = y({}, r)), t.forEachValue(function(s) {
+    var l = s.get();
+    if (Me(l)) {
+      var p = Fe(l, i);
+      p && s.set(p);
+    }
+  });
+  for (var o in a) {
+    var u = a[o];
+    if (Me(u)) {
+      var f = Fe(u, i);
+      f && (a[o] = f, r && ((n = r[o]) !== null && n !== void 0 || (r[o] = u)));
+    }
+  }
+  return { target: a, transitionEnd: r };
+}
+function jr(t, e) {
+  return t / (e.max - e.min) * 100;
+}
+function lu(t, e, r) {
+  var n = r.target;
+  if (typeof t == "string")
+    if (V.test(t))
+      t = parseFloat(t);
+    else
+      return t;
+  var a = jr(t, n.x), i = jr(t, n.y);
+  return a + "% " + i + "%";
+}
+var Hr = "_$css";
+function cu(t, e) {
+  var r = e.delta, n = e.treeScale, a = t, i = t.includes("var("), o = [];
+  i && (t = t.replace(qn, function(P) {
+    return o.push(P), Hr;
+  }));
+  var u = At.parse(t);
+  if (u.length > 5)
+    return a;
+  var f = At.createTransformer(t), s = typeof u[0] != "number" ? 1 : 0, l = r.x.scale * n.x, p = r.y.scale * n.y;
+  u[0 + s] /= l, u[1 + s] /= p;
+  var c = J(l, p, 0.5);
+  typeof u[2 + s] == "number" && (u[2 + s] /= c), typeof u[3 + s] == "number" && (u[3 + s] /= c);
+  var d = f(u);
+  if (i) {
+    var v = 0;
+    d = d.replace(Hr, function() {
+      var P = o[v];
+      return v++, P;
+    });
+  }
+  return d;
+}
+var Ct = {
+  process: lu
+}, vu = {
+  borderRadius: y(y({}, Ct), { applyTo: [
+    "borderTopLeftRadius",
+    "borderTopRightRadius",
+    "borderBottomLeftRadius",
+    "borderBottomRightRadius"
+  ] }),
+  borderTopLeftRadius: Ct,
+  borderTopRightRadius: Ct,
+  borderBottomLeftRadius: Ct,
+  borderBottomRightRadius: Ct,
+  boxShadow: {
+    process: cu
+  }
+}, _r = 1e3, du = (
+  /** @class */
+  (function(t) {
+    $r(e, t);
+    function e() {
+      var r = t !== null && t.apply(this, arguments) || this;
+      return r.frameTarget = ot(), r.currentAnimationTarget = ot(), r.isAnimating = {
+        x: !1,
+        y: !1
+      }, r.stopAxisAnimation = {
+        x: void 0,
+        y: void 0
+      }, r.isAnimatingTree = !1, r.animate = function(n, a, i) {
+        i === void 0 && (i = {});
+        var o = i.originBox, u = i.targetBox, f = i.visibilityAction, s = i.shouldStackAnimate, l = i.onComplete, p = i.prevParent, c = Z(i, ["originBox", "targetBox", "visibilityAction", "shouldStackAnimate", "onComplete", "prevParent"]), d = r.props, v = d.visualElement, P = d.layout;
+        if (s === !1)
+          return r.isAnimatingTree = !1, r.safeToRemove();
+        if (!(r.isAnimatingTree && s !== !0)) {
+          s && (r.isAnimatingTree = !0), a = o || a, n = u || n;
+          var m = !1, h = v.getProjectionParent();
+          if (h) {
+            var A = h.prevViewportBox, L = h.getLayoutState().layout;
+            p && (u && (L = p.getLayoutState().layout), o && !qo(p, h) && p.prevViewportBox && (A = p.prevViewportBox)), A && hu(p, o, u) && (m = !0, a = Vt(A, a), n = Vt(L, n));
+          }
+          var D = pu(a, n), C = N(function(x) {
+            var w, E;
+            if (P === "position") {
+              var S = n[x].max - n[x].min;
+              a[x].max = a[x].min + S;
+            }
+            if (!v.projection.isTargetLocked)
+              if (f !== void 0)
+                v.setVisibility(f === De.Show);
+              else return D ? r.animateAxis(x, n[x], a[x], y(y({}, c), { isRelative: m })) : ((E = (w = r.stopAxisAnimation)[x]) === null || E === void 0 || E.call(w), v.setProjectionTargetAxis(x, n[x].min, n[x].max, m));
+          });
+          return v.syncRender(), Promise.all(C).then(function() {
+            r.isAnimatingTree = !1, l && l(), v.notifyLayoutAnimationComplete();
+          });
+        }
+      }, r;
+    }
+    return e.prototype.componentDidMount = function() {
+      var r = this, n = this.props.visualElement;
+      n.animateMotionValue = ee, n.enableLayoutProjection(), this.unsubLayoutReady = n.onLayoutUpdate(this.animate), n.layoutSafeToRemove = function() {
+        return r.safeToRemove();
+      }, ri(vu);
+    }, e.prototype.componentWillUnmount = function() {
+      var r = this;
+      this.unsubLayoutReady(), N(function(n) {
+        var a, i;
+        return (i = (a = r.stopAxisAnimation)[n]) === null || i === void 0 ? void 0 : i.call(a);
+      });
+    }, e.prototype.animateAxis = function(r, n, a, i) {
+      var o = this, u, f, s = i === void 0 ? {} : i, l = s.transition, p = s.isRelative;
+      if (!(this.isAnimating[r] && Ot(n, this.currentAnimationTarget[r]))) {
+        (f = (u = this.stopAxisAnimation)[r]) === null || f === void 0 || f.call(u), this.isAnimating[r] = !0;
+        var c = this.props.visualElement, d = this.frameTarget[r], v = c.getProjectionAnimationProgress()[r];
+        v.clearListeners(), v.set(0), v.set(0);
+        var P = function() {
+          var L = v.get() / _r;
+          Zo(d, a, n, L), c.setProjectionTargetAxis(r, d.min, d.max, p);
+        };
+        P();
+        var m = v.onChange(P);
+        this.stopAxisAnimation[r] = function() {
+          o.isAnimating[r] = !1, v.stop(), m();
+        }, this.currentAnimationTarget[r] = n;
+        var h = l || c.getDefaultTransition() || gu, A = ee(r === "x" ? "layoutX" : "layoutY", v, _r, h && Ze(h, "layout")).then(this.stopAxisAnimation[r]);
+        return A;
+      }
+    }, e.prototype.safeToRemove = function() {
+      var r, n;
+      (n = (r = this.props).safeToRemove) === null || n === void 0 || n.call(r);
+    }, e.prototype.render = function() {
+      return null;
+    }, e;
+  })(U.Component)
+);
+function mu(t) {
+  var e = M(en(), 2), r = e[1];
+  return U.createElement(du, y({}, t, { safeToRemove: r }));
+}
+function pu(t, e) {
+  return !Nr(t) && !Nr(e) && (!Ot(t.x, e.x) || !Ot(t.y, e.y));
+}
+var Ur = { min: 0, max: 0 };
+function Nr(t) {
+  return Ot(t.x, Ur) && Ot(t.y, Ur);
+}
+function Ot(t, e) {
+  return t.min === e.min && t.max === e.max;
+}
+var gu = {
+  duration: 0.45,
+  ease: [0.4, 0, 0.1, 1]
+};
+function hu(t, e, r) {
+  return t || !t && !(e || r);
+}
+var yu = {
+  layoutReady: function(t) {
+    return t.notifyLayoutReady();
+  }
+};
+function $n() {
+  var t = /* @__PURE__ */ new Set();
+  return {
+    add: function(e) {
+      return t.add(e);
+    },
+    flush: function(e) {
+      var r = e === void 0 ? yu : e, n = r.layoutReady, a = r.parent;
+      we(function(i, o) {
+        var u = Array.from(t).sort($e), f = a ? re(a) : [];
+        o(function() {
+          var s = K(K([], M(f)), M(u));
+          s.forEach(function(l) {
+            return l.resetTransform();
+          });
+        }), i(function() {
+          u.forEach(Jt);
+        }), o(function() {
+          f.forEach(function(s) {
+            return s.restoreTransform();
+          }), u.forEach(n);
+        }), i(function() {
+          u.forEach(function(s) {
+            s.isPresent && (s.presence = Bt.Present);
+          });
+        }), o(function() {
+          bt.preRender(), bt.render();
+        }), i(function() {
+          rt.postRender(function() {
+            return u.forEach(Pu);
+          }), t.clear();
+        });
+      }), Re();
+    }
+  };
+}
+function Pu(t) {
+  t.prevViewportBox = t.projection.target;
+}
+var Jn = ht($n()), bu = ht($n());
+function dt(t) {
+  return !!t.forceUpdate;
+}
+var Tu = (
+  /** @class */
+  (function(t) {
+    $r(e, t);
+    function e() {
+      return t !== null && t.apply(this, arguments) || this;
+    }
+    return e.prototype.componentDidMount = function() {
+      var r = this.props, n = r.syncLayout, a = r.framerSyncLayout, i = r.visualElement;
+      dt(n) && n.register(i), dt(a) && a.register(i), i.onUnmount(function() {
+        dt(n) && n.remove(i), dt(a) && a.remove(i);
+      });
+    }, e.prototype.getSnapshotBeforeUpdate = function() {
+      var r = this.props, n = r.syncLayout, a = r.visualElement;
+      return dt(n) ? n.syncUpdate() : (Wo(a), n.add(a)), null;
+    }, e.prototype.componentDidUpdate = function() {
+      var r = this.props.syncLayout;
+      dt(r) || r.flush();
+    }, e.prototype.render = function() {
+      return null;
+    }, e;
+  })(Jr.Component)
+);
+function xu(t) {
+  var e = O(Jn), r = O(bu);
+  return Jr.createElement(Tu, y({}, t, { syncLayout: e, framerSyncLayout: r }));
+}
+var Au = {
+  measureLayout: xu,
+  layoutAnimation: mu
+}, Vu = function() {
+  return {
+    isEnabled: !1,
+    isHydrated: !1,
+    isTargetLocked: !1,
+    target: ot(),
+    targetFinal: ot()
+  };
+};
+function Qn() {
+  return {
+    isHydrated: !1,
+    layout: ot(),
+    layoutCorrected: ot(),
+    treeScale: { x: 1, y: 1 },
+    delta: Pr(),
+    deltaFinal: Pr(),
+    deltaTransform: ""
+  };
+}
+var Kr = Qn();
+function le(t, e, r) {
+  var n = t.x, a = t.y, i = n.translate / e.x, o = a.translate / e.y, u = "translate3d(" + i + "px, " + o + "px, 0) ";
+  if (r) {
+    var f = r.rotate, s = r.rotateX, l = r.rotateY;
+    f && (u += "rotate(" + f + ") "), s && (u += "rotateX(" + s + ") "), l && (u += "rotateY(" + l + ") ");
+  }
+  return u += "scale(" + n.scale + ", " + a.scale + ")", !r && u === Su ? "" : u;
+}
+function kn(t) {
+  var e = t.deltaFinal;
+  return e.x.origin * 100 + "% " + e.y.origin * 100 + "% 0";
+}
+var Su = le(Kr.delta, Kr.treeScale, {}), Wt = [
+  "LayoutMeasure",
+  "BeforeLayoutMeasure",
+  "LayoutUpdate",
+  "ViewportBoxUpdate",
+  "Update",
+  "Render",
+  "AnimationComplete",
+  "LayoutAnimationComplete",
+  "AnimationStart",
+  "SetAxisTarget",
+  "Unmount"
+];
+function Cu() {
+  var t = Wt.map(function() {
+    return new $t();
+  }), e = {}, r = {
+    clearAllListeners: function() {
+      return t.forEach(function(n) {
+        return n.clear();
+      });
+    },
+    updatePropListeners: function(n) {
+      return Wt.forEach(function(a) {
+        var i;
+        (i = e[a]) === null || i === void 0 || i.call(e);
+        var o = "on" + a, u = n[o];
+        u && (e[a] = r[o](u));
+      });
+    }
+  };
+  return t.forEach(function(n, a) {
+    r["on" + Wt[a]] = function(i) {
+      return n.add(i);
+    }, r["notify" + Wt[a]] = function() {
+      for (var i = [], o = 0; o < arguments.length; o++)
+        i[o] = arguments[o];
+      return n.notify.apply(n, K([], M(i)));
+    };
+  }), r;
+}
+function Eu(t, e, r) {
+  var n;
+  for (var a in e) {
+    var i = e[a], o = r[a];
+    if (it(i))
+      t.addValue(a, i);
+    else if (it(o))
+      t.addValue(a, pt(i));
+    else if (o !== i)
+      if (t.hasValue(a)) {
+        var u = t.getValue(a);
+        !u.hasAnimated && u.set(i);
+      } else
+        t.addValue(a, pt((n = t.getStaticValue(a)) !== null && n !== void 0 ? n : i));
+  }
+  for (var a in r)
+    e[a] === void 0 && t.removeValue(a);
+  return e;
+}
+function Lu(t, e, r, n) {
+  var a = t.delta, i = t.layout, o = t.layoutCorrected, u = t.treeScale, f = e.target;
+  $o(o, i), ko(o, u, r), Yn(a, o, f, n);
+}
+var wu = (
+  /** @class */
+  (function() {
+    function t() {
+      this.children = [], this.isDirty = !1;
+    }
+    return t.prototype.add = function(e) {
+      Mn(this.children, e), this.isDirty = !0;
+    }, t.prototype.remove = function(e) {
+      Fn(this.children, e), this.isDirty = !0;
+    }, t.prototype.forEach = function(e) {
+      this.isDirty && this.children.sort($e), this.isDirty = !1, this.children.forEach(e);
+    }, t;
+  })()
+);
+function Ru(t) {
+  var e = t.getProjectionParent();
+  if (!e) {
+    t.rebaseProjectionTarget();
+    return;
+  }
+  var r = Vt(e.getLayoutState().layout, t.getLayoutState().layout);
+  N(function(n) {
+    t.setProjectionTargetAxis(n, r[n].min, r[n].max, !0);
+  });
+}
+var ta = function(t) {
+  var e = t.treeType, r = e === void 0 ? "" : e, n = t.build, a = t.getBaseTarget, i = t.makeTargetAnimatable, o = t.measureViewportBox, u = t.render, f = t.readValueFromInstance, s = t.resetTransform, l = t.restoreTransform, p = t.removeValueFromRenderState, c = t.sortNodePosition, d = t.scrapeMotionValuesFromProps;
+  return function(v, P) {
+    var m = v.parent, h = v.props, A = v.presenceId, L = v.blockInitialAnimation, D = v.visualState;
+    P === void 0 && (P = {});
+    var C = D.latestValues, x = D.renderState, w, E = Cu(), S = Vu(), I, _ = S, k = C, X, j = Qn(), ut, tt = !1, nt = /* @__PURE__ */ new Map(), st = /* @__PURE__ */ new Map(), _t = {}, ft, Y = y({}, C), q;
+    function lt() {
+      w && (T.isProjectionReady() && (Le(_.targetFinal, _.target, k), Yn(j.deltaFinal, j.layoutCorrected, _.targetFinal, C)), ct(), u(w, x));
+    }
+    function ct() {
+      var g = C;
+      if (ut && ut.isActive()) {
+        var b = ut.getCrossfadeState(T);
+        b && (g = b);
+      }
+      n(T, x, g, _, j, P, h);
+    }
+    function Je() {
+      E.notifyUpdate(C);
+    }
+    function ia() {
+      if (T.isProjectionReady()) {
+        var g = j.delta, b = j.treeScale, R = b.x, B = b.y, H = j.deltaTransform;
+        Lu(j, _, T.path, C), tt && T.notifyViewportBoxUpdate(_.target, g), tt = !1;
+        var z = le(g, b);
+        (z !== H || // Also compare calculated treeScale, for values that rely on this only for scale correction
+        R !== b.x || B !== b.y) && T.scheduleRender(), j.deltaTransform = z;
+      }
+    }
+    function oa() {
+      T.layoutTree.forEach(Mu);
+    }
+    function ua(g, b) {
+      var R = b.onChange(function(H) {
+        C[g] = H, h.onUpdate && rt.update(Je, !1, !0);
+      }), B = b.onRenderRequest(T.scheduleRender);
+      st.set(g, function() {
+        R(), B();
+      });
+    }
+    var Qe = d(h);
+    for (var ce in Qe) {
+      var ke = Qe[ce];
+      C[ce] !== void 0 && it(ke) && ke.set(C[ce], !1);
+    }
+    var tr = ue(h), ve = on(h), T = y(y({
+      treeType: r,
+      /**
+       * This is a mirror of the internal instance prop, which keeps
+       * VisualElement type-compatible with React's RefObject.
+       */
+      current: null,
+      /**
+       * The depth of this visual element within the visual element tree.
+       */
+      depth: m ? m.depth + 1 : 0,
+      parent: m,
+      children: /* @__PURE__ */ new Set(),
+      /**
+       * An ancestor path back to the root visual element. This is used
+       * by layout projection to quickly recurse back up the tree.
+       */
+      path: m ? K(K([], M(m.path)), [m]) : [],
+      layoutTree: m ? m.layoutTree : new wu(),
+      /**
+       *
+       */
+      presenceId: A,
+      projection: S,
+      /**
+       * If this component is part of the variant tree, it should track
+       * any children that are also part of the tree. This is essentially
+       * a shadow tree to simplify logic around how to stagger over children.
+       */
+      variantChildren: ve ? /* @__PURE__ */ new Set() : void 0,
+      /**
+       * Whether this instance is visible. This can be changed imperatively
+       * by AnimateSharedLayout, is analogous to CSS's visibility in that
+       * hidden elements should take up layout, and needs enacting by the configured
+       * render function.
+       */
+      isVisible: void 0,
+      /**
+       * Normally, if a component is controlled by a parent's variants, it can
+       * rely on that ancestor to trigger animations further down the tree.
+       * However, if a component is created after its parent is mounted, the parent
+       * won't trigger that mount animation so the child needs to.
+       *
+       * TODO: This might be better replaced with a method isParentMounted
+       */
+      manuallyAnimateOnMount: !!m?.isMounted(),
+      /**
+       * This can be set by AnimatePresence to force components that mount
+       * at the same time as it to mount as if they have initial={false} set.
+       */
+      blockInitialAnimation: L,
+      /**
+       * Determine whether this component has mounted yet. This is mostly used
+       * by variant children to determine whether they need to trigger their
+       * own animations on mount.
+       */
+      isMounted: function() {
+        return !!w;
+      },
+      mount: function(g) {
+        w = T.current = g, T.pointTo(T), ve && m && !tr && (q = m?.addVariantChild(T)), m?.children.add(T);
+      },
+      /**
+       *
+       */
+      unmount: function() {
+        qt.update(Je), qt.render(lt), qt.preRender(T.updateLayoutProjection), st.forEach(function(g) {
+          return g();
+        }), T.stopLayoutAnimation(), T.layoutTree.remove(T), q?.(), m?.children.delete(T), X?.(), E.clearAllListeners();
+      },
+      /**
+       * Add a child visual element to our set of children.
+       */
+      addVariantChild: function(g) {
+        var b, R = T.getClosestVariantNode();
+        if (R)
+          return (b = R.variantChildren) === null || b === void 0 || b.add(g), function() {
+            return R.variantChildren.delete(g);
+          };
+      },
+      sortNodePosition: function(g) {
+        return !c || r !== g.treeType ? 0 : c(T.getInstance(), g.getInstance());
+      },
+      /**
+       * Returns the closest variant node in the tree starting from
+       * this visual element.
+       */
+      getClosestVariantNode: function() {
+        return ve ? T : m?.getClosestVariantNode();
+      },
+      /**
+       * A method that schedules an update to layout projections throughout
+       * the tree. We inherit from the parent so there's only ever one
+       * job scheduled on the next frame - that of the root visual element.
+       */
+      scheduleUpdateLayoutProjection: m ? m.scheduleUpdateLayoutProjection : function() {
+        return rt.preRender(T.updateTreeLayoutProjection, !1, !0);
+      },
+      /**
+       * Expose the latest layoutId prop.
+       */
+      getLayoutId: function() {
+        return h.layoutId;
+      },
+      /**
+       * Returns the current instance.
+       */
+      getInstance: function() {
+        return w;
+      },
+      /**
+       * Get/set the latest static values.
+       */
+      getStaticValue: function(g) {
+        return C[g];
+      },
+      setStaticValue: function(g, b) {
+        return C[g] = b;
+      },
+      /**
+       * Returns the latest motion value state. Currently only used to take
+       * a snapshot of the visual element - perhaps this can return the whole
+       * visual state
+       */
+      getLatestValues: function() {
+        return C;
+      },
+      /**
+       * Set the visiblity of the visual element. If it's changed, schedule
+       * a render to reflect these changes.
+       */
+      setVisibility: function(g) {
+        T.isVisible !== g && (T.isVisible = g, T.scheduleRender());
+      },
+      /**
+       * Make a target animatable by Popmotion. For instance, if we're
+       * trying to animate width from 100px to 100vw we need to measure 100vw
+       * in pixels to determine what we really need to animate to. This is also
+       * pluggable to support Framer's custom value types like Color,
+       * and CSS variables.
+       */
+      makeTargetAnimatable: function(g, b) {
+        return b === void 0 && (b = !0), i(T, g, h, b);
+      },
+      // Motion values ========================
+      /**
+       * Add a motion value and bind it to this visual element.
+       */
+      addValue: function(g, b) {
+        T.hasValue(g) && T.removeValue(g), nt.set(g, b), C[g] = b.get(), ua(g, b);
+      },
+      /**
+       * Remove a motion value and unbind any active subscriptions.
+       */
+      removeValue: function(g) {
+        var b;
+        nt.delete(g), (b = st.get(g)) === null || b === void 0 || b(), st.delete(g), delete C[g], p(g, x);
+      },
+      /**
+       * Check whether we have a motion value for this key
+       */
+      hasValue: function(g) {
+        return nt.has(g);
+      },
+      /**
+       * Get a motion value for this key. If called with a default
+       * value, we'll create one if none exists.
+       */
+      getValue: function(g, b) {
+        var R = nt.get(g);
+        return R === void 0 && b !== void 0 && (R = pt(b), T.addValue(g, R)), R;
+      },
+      /**
+       * Iterate over our motion values.
+       */
+      forEachValue: function(g) {
+        return nt.forEach(g);
+      },
+      /**
+       * If we're trying to animate to a previously unencountered value,
+       * we need to check for it in our state and as a last resort read it
+       * directly from the instance (which might have performance implications).
+       */
+      readValue: function(g) {
+        var b;
+        return (b = C[g]) !== null && b !== void 0 ? b : f(w, g, P);
+      },
+      /**
+       * Set the base target to later animate back to. This is currently
+       * only hydrated on creation and when we first read a value.
+       */
+      setBaseTarget: function(g, b) {
+        Y[g] = b;
+      },
+      /**
+       * Find the base target for a value thats been removed from all animation
+       * props.
+       */
+      getBaseTarget: function(g) {
+        if (a) {
+          var b = a(h, g);
+          if (b !== void 0 && !it(b))
+            return b;
+        }
+        return Y[g];
+      }
+    }, E), {
+      /**
+       * Build the renderer state based on the latest visual state.
+       */
+      build: function() {
+        return ct(), x;
+      },
+      /**
+       * Schedule a render on the next animation frame.
+       */
+      scheduleRender: function() {
+        rt.render(lt, !1, !0);
+      },
+      /**
+       * Synchronously fire render. It's prefered that we batch renders but
+       * in many circumstances, like layout measurement, we need to run this
+       * synchronously. However in those instances other measures should be taken
+       * to batch reads/writes.
+       */
+      syncRender: lt,
+      /**
+       * Update the provided props. Ensure any newly-added motion values are
+       * added to our map, old ones removed, and listeners updated.
+       */
+      setProps: function(g) {
+        h = g, E.updatePropListeners(g), _t = Eu(T, d(h), _t);
+      },
+      getProps: function() {
+        return h;
+      },
+      // Variants ==============================
+      /**
+       * Returns the variant definition with a given name.
+       */
+      getVariant: function(g) {
+        var b;
+        return (b = h.variants) === null || b === void 0 ? void 0 : b[g];
+      },
+      /**
+       * Returns the defined default transition on this component.
+       */
+      getDefaultTransition: function() {
+        return h.transition;
+      },
+      /**
+       * Used by child variant nodes to get the closest ancestor variant props.
+       */
+      getVariantContext: function(g) {
+        if (g === void 0 && (g = !1), g)
+          return m?.getVariantContext();
+        if (!tr) {
+          var b = m?.getVariantContext() || {};
+          return h.initial !== void 0 && (b.initial = h.initial), b;
+        }
+        for (var R = {}, B = 0; B < Fu; B++) {
+          var H = ea[B], z = h[H];
+          (W(z) || z === !1) && (R[H] = z);
+        }
+        return R;
+      },
+      // Layout projection ==============================
+      /**
+       * Enable layout projection for this visual element. Won't actually
+       * occur until we also have hydrated layout measurements.
+       */
+      enableLayoutProjection: function() {
+        S.isEnabled = !0, T.layoutTree.add(T);
+      },
+      /**
+       * Lock the projection target, for instance when dragging, so
+       * nothing else can try and animate it.
+       */
+      lockProjectionTarget: function() {
+        S.isTargetLocked = !0;
+      },
+      unlockProjectionTarget: function() {
+        T.stopLayoutAnimation(), S.isTargetLocked = !1;
+      },
+      getLayoutState: function() {
+        return j;
+      },
+      setCrossfader: function(g) {
+        ut = g;
+      },
+      isProjectionReady: function() {
+        return S.isEnabled && S.isHydrated && j.isHydrated;
+      },
+      /**
+       * Start a layout animation on a given axis.
+       */
+      startLayoutAnimation: function(g, b, R) {
+        R === void 0 && (R = !1);
+        var B = T.getProjectionAnimationProgress()[g], H = R ? S.relativeTarget[g] : S.target[g], z = H.min, Ut = H.max, Nt = Ut - z;
+        return B.clearListeners(), B.set(z), B.set(z), B.onChange(function(Kt) {
+          T.setProjectionTargetAxis(g, Kt, Kt + Nt, R);
+        }), T.animateMotionValue(g, B, 0, b);
+      },
+      /**
+       * Stop layout animations.
+       */
+      stopLayoutAnimation: function() {
+        N(function(g) {
+          return T.getProjectionAnimationProgress()[g].stop();
+        });
+      },
+      /**
+       * Measure the current viewport box with or without transforms.
+       * Only measures axis-aligned boxes, rotate and skew must be manually
+       * removed with a re-render to work.
+       */
+      measureViewportBox: function(g) {
+        g === void 0 && (g = !0);
+        var b = o(w, P);
+        return g || Zn(b, C), b;
+      },
+      /**
+       * Get the motion values tracking the layout animations on each
+       * axis. Lazy init if not already created.
+       */
+      getProjectionAnimationProgress: function() {
+        return ft || (ft = {
+          x: pt(0),
+          y: pt(0)
+        }), ft;
+      },
+      /**
+       * Update the projection of a single axis. Schedule an update to
+       * the tree layout projection.
+       */
+      setProjectionTargetAxis: function(g, b, R, B) {
+        B === void 0 && (B = !1);
+        var H;
+        B ? (S.relativeTarget || (S.relativeTarget = ot()), H = S.relativeTarget[g]) : (S.relativeTarget = void 0, H = S.target[g]), S.isHydrated = !0, H.min = b, H.max = R, tt = !0, E.notifySetAxisTarget();
+      },
+      /**
+       * Rebase the projection target on top of the provided viewport box
+       * or the measured layout. This ensures that non-animating elements
+       * don't fall out of sync differences in measurements vs projections
+       * after a page scroll or other relayout.
+       */
+      rebaseProjectionTarget: function(g, b) {
+        b === void 0 && (b = j.layout);
+        var R = T.getProjectionAnimationProgress(), B = R.x, H = R.y, z = !S.relativeTarget && !S.isTargetLocked && !B.isAnimating() && !H.isAnimating();
+        (g || z) && N(function(Ut) {
+          var Nt = b[Ut], Kt = Nt.min, sa = Nt.max;
+          T.setProjectionTargetAxis(Ut, Kt, sa);
+        });
+      },
+      /**
+       * Notify the visual element that its layout is up-to-date.
+       * Currently Animate.tsx uses this to check whether a layout animation
+       * needs to be performed.
+       */
+      notifyLayoutReady: function(g) {
+        Ru(T), T.notifyLayoutUpdate(j.layout, T.prevViewportBox || j.layout, g);
+      },
+      /**
+       * Temporarily reset the transform of the instance.
+       */
+      resetTransform: function() {
+        return s(T, w, h);
+      },
+      restoreTransform: function() {
+        return l(w, x);
+      },
+      updateLayoutProjection: ia,
+      updateTreeLayoutProjection: function() {
+        T.layoutTree.forEach(Du), rt.preRender(oa, !1, !0);
+      },
+      getProjectionParent: function() {
+        if (I === void 0) {
+          for (var g = !1, b = T.path.length - 1; b >= 0; b--) {
+            var R = T.path[b];
+            if (R.projection.isEnabled) {
+              g = R;
+              break;
+            }
+          }
+          I = g;
+        }
+        return I;
+      },
+      resolveRelativeTargetBox: function() {
+        var g = T.getProjectionParent();
+        if (!(!S.relativeTarget || !g) && (zo(S, g.projection), zn(g))) {
+          var b = S.target;
+          Le(b, b, g.getLatestValues());
+        }
+      },
+      shouldResetTransform: function() {
+        return !!h._layoutResetTransform;
+      },
+      /**
+       *
+       */
+      pointTo: function(g) {
+        _ = g.projection, k = g.getLatestValues(), X?.(), X = Be(g.onSetAxisTarget(T.scheduleUpdateLayoutProjection), g.onLayoutAnimationComplete(function() {
+          var b;
+          T.isPresent ? T.presence = Bt.Present : (b = T.layoutSafeToRemove) === null || b === void 0 || b.call(T);
+        }));
+      },
+      // TODO: Clean this up
+      isPresent: !0,
+      presence: Bt.Entering
+    });
+    return T;
+  };
+};
+function Du(t) {
+  t.resolveRelativeTargetBox();
+}
+function Mu(t) {
+  t.updateLayoutProjection();
+}
+var ea = K(["initial"], M(qe)), Fu = ea.length, Iu = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "x",
+  "y"
+]), ra = function(t) {
+  return Iu.has(t);
+}, Bu = function(t) {
+  return Object.keys(t).some(ra);
+}, na = function(t, e) {
+  t.set(e, !1), t.set(e);
+}, Zt = function(t) {
+  return t === Ie || t === V;
+}, Yr;
+(function(t) {
+  t.width = "width", t.height = "height", t.left = "left", t.right = "right", t.top = "top", t.bottom = "bottom";
+})(Yr || (Yr = {}));
+var Xr = function(t, e) {
+  return parseFloat(t.split(", ")[e]);
+}, zr = function(t, e) {
+  return function(r, n) {
+    var a = n.transform;
+    if (a === "none" || !a)
+      return 0;
+    var i = a.match(/^matrix3d\((.+)\)$/);
+    if (i)
+      return Xr(i[1], e);
+    var o = a.match(/^matrix\((.+)\)$/);
+    return o ? Xr(o[1], t) : 0;
+  };
+}, Ou = /* @__PURE__ */ new Set(["x", "y", "z"]), ju = Dt.filter(function(t) {
+  return !Ou.has(t);
+});
+function Hu(t) {
+  var e = [];
+  return ju.forEach(function(r) {
+    var n = t.getValue(r);
+    n !== void 0 && (e.push([r, n.get()]), n.set(r.startsWith("scale") ? 1 : 0));
+  }), e.length && t.syncRender(), e;
+}
+var Gr = {
+  // Dimensions
+  width: function(t) {
+    var e = t.x;
+    return e.max - e.min;
+  },
+  height: function(t) {
+    var e = t.y;
+    return e.max - e.min;
+  },
+  top: function(t, e) {
+    var r = e.top;
+    return parseFloat(r);
+  },
+  left: function(t, e) {
+    var r = e.left;
+    return parseFloat(r);
+  },
+  bottom: function(t, e) {
+    var r = t.y, n = e.top;
+    return parseFloat(n) + (r.max - r.min);
+  },
+  right: function(t, e) {
+    var r = t.x, n = e.left;
+    return parseFloat(n) + (r.max - r.min);
+  },
+  // Transform
+  x: zr(4, 13),
+  y: zr(5, 14)
+}, _u = function(t, e, r) {
+  var n = e.measureViewportBox(), a = e.getInstance(), i = getComputedStyle(a), o = i.display, u = i.top, f = i.left, s = i.bottom, l = i.right, p = i.transform, c = { top: u, left: f, bottom: s, right: l, transform: p };
+  o === "none" && e.setStaticValue("display", t.display || "block"), e.syncRender();
+  var d = e.measureViewportBox();
+  return r.forEach(function(v) {
+    var P = e.getValue(v);
+    na(P, Gr[v](n, c)), t[v] = Gr[v](d, i);
+  }), t;
+}, Uu = function(t, e, r, n) {
+  r === void 0 && (r = {}), n === void 0 && (n = {}), e = y({}, e), n = y({}, n);
+  var a = Object.keys(e).filter(ra), i = [], o = !1, u = [];
+  if (a.forEach(function(s) {
+    var l = t.getValue(s);
+    if (t.hasValue(s)) {
+      var p = r[s], c = e[s], d = zt(p), v;
+      if (Mt(c))
+        for (var P = c.length, m = c[0] === null ? 1 : 0; m < P; m++)
+          v ? gt(zt(c[m]) === v, "All keyframes must be of the same type") : (v = zt(c[m]), gt(v === d || Zt(d) && Zt(v), "Keyframes must be of the same dimension as the current value"));
+      else
+        v = zt(c);
+      if (d !== v)
+        if (Zt(d) && Zt(v)) {
+          var h = l.get();
+          typeof h == "string" && l.set(parseFloat(h)), typeof c == "string" ? e[s] = parseFloat(c) : Array.isArray(c) && v === V && (e[s] = c.map(parseFloat));
+        } else d?.transform && v?.transform && (p === 0 || c === 0) ? p === 0 ? l.set(v.transform(p)) : e[s] = d.transform(c) : (o || (i = Hu(t), o = !0), u.push(s), n[s] = n[s] !== void 0 ? n[s] : e[s], na(l, c));
+    }
+  }), u.length) {
+    var f = _u(e, t, u);
+    return i.length && i.forEach(function(s) {
+      var l = M(s, 2), p = l[0], c = l[1];
+      t.getValue(p).set(c);
+    }), t.syncRender(), { target: f, transitionEnd: n };
+  } else
+    return { target: e, transitionEnd: n };
+};
+function Nu(t, e, r, n) {
+  return Bu(e) ? Uu(t, e, r, n) : { target: e, transitionEnd: n };
+}
+var Ku = function(t, e, r, n) {
+  var a = fu(t, e, n);
+  return e = a.target, n = a.transitionEnd, Nu(t, e, r, n);
+};
+function Yu(t) {
+  return window.getComputedStyle(t);
+}
+var aa = {
+  treeType: "dom",
+  readValueFromInstance: function(t, e) {
+    if (se(e)) {
+      var r = Ge(e);
+      return r && r.default || 0;
+    } else {
+      var n = Yu(t);
+      return (fn(e) ? n.getPropertyValue(e) : n[e]) || 0;
+    }
+  },
+  sortNodePosition: function(t, e) {
+    return t.compareDocumentPosition(e) & 2 ? 1 : -1;
+  },
+  getBaseTarget: function(t, e) {
+    var r;
+    return (r = t.style) === null || r === void 0 ? void 0 : r[e];
+  },
+  measureViewportBox: function(t, e) {
+    var r = e.transformPagePoint;
+    return Kn(t, r);
+  },
+  /**
+   * Reset the transform on the current Element. This is called as part
+   * of a batched process across the entire layout tree. To remove this write
+   * cycle it'd be interesting to see if it's possible to "undo" all the current
+   * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms
+   * works
+   */
+  resetTransform: function(t, e, r) {
+    var n = r.transformTemplate;
+    e.style.transform = n ? n({}, "") : "none", t.scheduleRender();
+  },
+  restoreTransform: function(t, e) {
+    t.style.transform = e.style.transform;
+  },
+  removeValueFromRenderState: function(t, e) {
+    var r = e.vars, n = e.style;
+    delete r[t], delete n[t];
+  },
+  /**
+   * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`
+   * can be animated by Motion.
+   */
+  makeTargetAnimatable: function(t, e, r, n) {
+    var a = r.transformValues;
+    n === void 0 && (n = !0);
+    var i = e.transition, o = e.transitionEnd, u = Z(e, ["transition", "transitionEnd"]), f = Po(u, i || {}, t);
+    if (a && (o && (o = a(o)), u && (u = a(u)), f && (f = a(f))), n) {
+      ho(t, u, f);
+      var s = Ku(t, u, f, o);
+      o = s.transitionEnd, u = s.target;
+    }
+    return y({
+      transition: i,
+      transitionEnd: o
+    }, u);
+  },
+  scrapeMotionValuesFromProps: Ne,
+  build: function(t, e, r, n, a, i, o) {
+    t.isVisible !== void 0 && (e.style.visibility = t.isVisible ? "visible" : "hidden");
+    var u = n.isEnabled && a.isHydrated;
+    He(e, r, n, a, i, o.transformTemplate, u ? le : void 0, u ? kn : void 0);
+  },
+  render: pn
+}, Xu = ta(aa), zu = ta(y(y({}, aa), {
+  getBaseTarget: function(t, e) {
+    return t[e];
+  },
+  readValueFromInstance: function(t, e) {
+    var r;
+    return se(e) ? ((r = Ge(e)) === null || r === void 0 ? void 0 : r.default) || 0 : (e = gn.has(e) ? e : mn(e), t.getAttribute(e));
+  },
+  scrapeMotionValuesFromProps: yn,
+  build: function(t, e, r, n, a, i, o) {
+    var u = n.isEnabled && a.isHydrated;
+    Ue(e, r, n, a, i, o.transformTemplate, u ? le : void 0, u ? kn : void 0);
+  },
+  render: hn
+})), Gu = function(t, e) {
+  return je(t) ? zu(e, { enableHardwareAcceleration: !1 }) : Xu(e, { enableHardwareAcceleration: !0 });
+}, Wu = y(y(y(y({}, Ro), Gi), ou), Au), rs = /* @__PURE__ */ ti(function(t, e) {
+  return Mi(t, e, Wu, Gu);
+});
+function Zu() {
+  var t = $(!1), e = M(Ia(0), 2), r = e[0], n = e[1];
+  return ze(function() {
+    return t.current = !0;
+  }), Qr(function() {
+    !t.current && n(r + 1);
+  }, [r]);
+}
+var Wr = 0;
+function qu() {
+  var t = Wr;
+  return Wr++, t;
+}
+var ye = function(t) {
+  var e = t.children, r = t.initial, n = t.isPresent, a = t.onExitComplete, i = t.custom, o = t.presenceAffectsLayout, u = Rt($u), f = Rt(qu), s = wt(
+    function() {
+      return {
+        id: f,
+        initial: r,
+        isPresent: n,
+        custom: i,
+        onExitComplete: function(l) {
+          u.set(l, !0);
+          var p = !0;
+          u.forEach(function(c) {
+            c || (p = !1);
+          }), p && a?.();
+        },
+        register: function(l) {
+          return u.set(l, !1), function() {
+            return u.delete(l);
+          };
+        }
+      };
+    },
+    /**
+     * If the presence of a child affects the layout of the components around it,
+     * we want to make a new context value to ensure they get re-rendered
+     * so they can detect that layout change.
+     */
+    o ? void 0 : [n]
+  );
+  return wt(function() {
+    u.forEach(function(l, p) {
+      return u.set(p, !1);
+    });
+  }, [n]), U.useEffect(function() {
+    !n && !u.size && a?.();
+  }, [n]), U.createElement(St.Provider, { value: s }, e);
+};
+function $u() {
+  return /* @__PURE__ */ new Map();
+}
+function Pt(t) {
+  return t.key || "";
+}
+function Ju(t, e) {
+  var r = process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Set() : null;
+  t.forEach(function(n) {
+    var a = Pt(n);
+    process.env.NODE_ENV !== "production" && r && (r.has(a) && console.warn('Children of AnimatePresence require unique keys. "' + a + '" is a duplicate.'), r.add(a)), e.set(a, n);
+  });
+}
+function Qu(t) {
+  var e = [];
+  return Oa.forEach(t, function(r) {
+    ja(r) && e.push(r);
+  }), e;
+}
+var ns = function(t) {
+  var e = t.children, r = t.custom, n = t.initial, a = n === void 0 ? !0 : n, i = t.onExitComplete, o = t.exitBeforeEnter, u = t.presenceAffectsLayout, f = u === void 0 ? !0 : u, s = Zu(), l = O(Jn);
+  dt(l) && (s = l.forceUpdate);
+  var p = $(!0), c = Qu(e), d = $(c), v = $(/* @__PURE__ */ new Map()).current, P = $(/* @__PURE__ */ new Set()).current;
+  if (Ju(c, v), p.current)
+    return p.current = !1, U.createElement(U.Fragment, null, c.map(function(x) {
+      return U.createElement(ye, { key: Pt(x), isPresent: !0, initial: a ? void 0 : !1, presenceAffectsLayout: f }, x);
+    }));
+  for (var m = K([], M(c)), h = d.current.map(Pt), A = c.map(Pt), L = h.length, D = 0; D < L; D++) {
+    var C = h[D];
+    A.indexOf(C) === -1 ? P.add(C) : P.delete(C);
+  }
+  return o && P.size && (m = []), P.forEach(function(x) {
+    if (A.indexOf(x) === -1) {
+      var w = v.get(x);
+      if (w) {
+        var E = h.indexOf(x), S = function() {
+          v.delete(x), P.delete(x);
+          var I = d.current.findIndex(function(_) {
+            return _.key === x;
+          });
+          d.current.splice(I, 1), P.size || (d.current = c, s(), i && i());
+        };
+        m.splice(E, 0, U.createElement(ye, { key: Pt(w), isPresent: !1, onExitComplete: S, custom: r, presenceAffectsLayout: f }, w));
+      }
+    }
+  }), m = m.map(function(x) {
+    var w = x.key;
+    return P.has(w) ? x : U.createElement(ye, { key: Pt(x), isPresent: !0, presenceAffectsLayout: f }, x);
+  }), d.current = m, process.env.NODE_ENV !== "production" && o && m.length > 1 && console.warn("You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour."), U.createElement(U.Fragment, null, P.size ? m : m.map(function(x) {
+    return Ba(x);
+  }));
+};
+export {
+  ns as A,
+  en as a,
+  rs as m,
+  es as u
+};