@lanaco/lnc-react-ui 3.11.35 → 4.0.2

package/dist/motion-CtkUpWEn.js

@@ -0,0 +1,3785 @@
+import { a as h, b as J, c as W, d as H, e as Ln } from "./tslib.es6-ZNVz5r_T.js";
+import * as St from "react";
+import wn, { createContext as pt, useContext as z, useRef as It, useEffect as at, useLayoutEffect as fo, useCallback as lo, useMemo as re, forwardRef as co, createElement as vo } from "react";
+var ot = function(t) {
+  return {
+    isEnabled: function(r) {
+      return t.some(function(e) {
+        return !!r[e];
+      });
+    }
+  };
+}, ee = {
+  measureLayout: ot([
+    "layout",
+    "layoutId",
+    "drag",
+    "_layoutResetTransform"
+  ]),
+  animation: ot([
+    "animate",
+    "exit",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "whileFocus",
+    "whileDrag"
+  ]),
+  exit: ot(["exit"]),
+  drag: ot(["drag", "dragControls"]),
+  focus: ot(["whileFocus"]),
+  hover: ot(["whileHover", "onHoverStart", "onHoverEnd"]),
+  tap: ot(["whileTap", "onTap", "onTapStart", "onTapCancel"]),
+  pan: ot([
+    "onPan",
+    "onPanStart",
+    "onPanSessionStart",
+    "onPanEnd"
+  ]),
+  layoutAnimation: ot(["layout", "layoutId"])
+};
+function mo(t) {
+  for (var r in t) {
+    var e = t[r];
+    e !== null && (ee[r].Component = e);
+  }
+}
+var br = function() {
+}, X = function() {
+};
+process.env.NODE_ENV !== "production" && (br = function(t, r) {
+  !t && typeof console < "u" && console.warn(r);
+}, X = function(t, r) {
+  if (!t)
+    throw new Error(r);
+});
+var En = pt({ strict: !1 }), Mn = Object.keys(ee), po = Mn.length;
+function go(t, r, e) {
+  var n = [], a = z(En);
+  if (!r)
+    return null;
+  process.env.NODE_ENV !== "production" && e && a.strict && X(!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 o = 0; o < po; o++) {
+    var i = Mn[o], u = ee[i], f = u.isEnabled, s = u.Component;
+    f(t) && s && n.push(St.createElement(s, h({ key: i }, t, { visualElement: r })));
+  }
+  return n;
+}
+var Pr = pt({
+  transformPagePoint: function(t) {
+    return t;
+  },
+  isStatic: !1
+}), xr = pt({});
+function ho() {
+  return z(xr).visualElement;
+}
+var Tr = pt(null);
+function ne(t) {
+  var r = It(null);
+  return r.current === null && (r.current = t()), r.current;
+}
+function Dn() {
+  var t = z(Tr);
+  if (t === null)
+    return [!0, null];
+  var r = t.isPresent, e = t.onExitComplete, n = t.register, a = xo();
+  at(function() {
+    return n(a);
+  }, []);
+  var o = function() {
+    return e == null ? void 0 : e(a);
+  };
+  return !r && e ? [!1, o] : [!0];
+}
+function yo(t) {
+  return t === null ? !0 : t.isPresent;
+}
+var bo = 0, Po = function() {
+  return bo++;
+}, xo = function() {
+  return ne(Po);
+}, To = pt(null), zt = typeof window < "u", Ce = zt ? fo : at;
+function So(t) {
+  var r = t.layoutId, e = z(To);
+  return e && r !== void 0 ? e + "-" + r : r;
+}
+function Ao(t, r, e, n) {
+  var a = z(Pr), o = z(En), i = ho(), u = z(Tr), f = So(e), s = It(void 0);
+  n || (n = o.renderer), !s.current && n && (s.current = n(t, {
+    visualState: r,
+    parent: i,
+    props: h(h({}, e), { layoutId: f }),
+    presenceId: u == null ? void 0 : u.id,
+    blockInitialAnimation: (u == null ? void 0 : u.initial) === !1
+  }));
+  var l = s.current;
+  return Ce(function() {
+    l && (l.setProps(h(h(h({}, a), e), { layoutId: f })), l.isPresent = yo(u), l.isPresenceRoot = !i || i.presenceId !== (u == null ? void 0 : u.id), l.syncRender());
+  }), at(function() {
+    var m;
+    l && ((m = l.animationState) === null || m === void 0 || m.animateChanges());
+  }), Ce(function() {
+    return function() {
+      return l == null ? void 0 : l.notifyUnmount();
+    };
+  }, []), l;
+}
+function jr(t) {
+  return typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+function Vo(t, r, e) {
+  return lo(
+    function(n) {
+      var a;
+      n && ((a = t.mount) === null || a === void 0 || a.call(t, n)), r && (n ? r.mount(n) : r.unmount()), e && (typeof e == "function" ? e(n) : jr(e) && (e.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.
+     */
+    [r]
+  );
+}
+function Rn(t) {
+  return Array.isArray(t);
+}
+function rt(t) {
+  return typeof t == "string" || Rn(t);
+}
+function Co(t) {
+  var r = {};
+  return t.forEachValue(function(e, n) {
+    return r[n] = e.get();
+  }), r;
+}
+function Lo(t) {
+  var r = {};
+  return t.forEachValue(function(e, n) {
+    return r[n] = e.getVelocity();
+  }), r;
+}
+function On(t, r, e, n, a) {
+  var o;
+  return n === void 0 && (n = {}), a === void 0 && (a = {}), typeof r == "string" && (r = (o = t.variants) === null || o === void 0 ? void 0 : o[r]), typeof r == "function" ? r(e ?? t.custom, n, a) : r;
+}
+function Sr(t, r, e) {
+  var n = t.getProps();
+  return On(n, r, e ?? n.custom, Co(t), Lo(t));
+}
+function Ar(t) {
+  var r;
+  return typeof ((r = t.animate) === null || r === void 0 ? void 0 : r.start) == "function" || rt(t.initial) || rt(t.animate) || rt(t.whileHover) || rt(t.whileDrag) || rt(t.whileTap) || rt(t.whileFocus) || rt(t.exit);
+}
+function In(t) {
+  return !!(Ar(t) || t.variants);
+}
+function wo(t, r) {
+  if (Ar(t)) {
+    var e = t.initial, n = t.animate;
+    return {
+      initial: e === !1 || rt(e) ? e : void 0,
+      animate: rt(n) ? n : void 0
+    };
+  }
+  return t.inherit !== !1 ? r : {};
+}
+function Eo(t, r) {
+  var e = wo(t, z(xr)), n = e.initial, a = e.animate;
+  return re(
+    function() {
+      return { initial: n, animate: a };
+    },
+    /**
+     * Only break memoisation in static mode
+     */
+    r ? [
+      Le(n),
+      Le(a)
+    ] : []
+  );
+}
+function Le(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+function Mo(t) {
+  var r = t.preloadedFeatures, e = t.createVisualElement, n = t.useRender, a = t.useVisualState, o = t.Component;
+  r && mo(r);
+  function i(u, f) {
+    var s = z(Pr).isStatic, l = null, m = Eo(u, s), v = a(u, s);
+    return !s && zt && (m.visualElement = Ao(o, v, u, e), l = go(u, m.visualElement, r)), St.createElement(
+      St.Fragment,
+      null,
+      St.createElement(xr.Provider, { value: m }, n(o, u, Vo(v, m.visualElement, f), v, s)),
+      l
+    );
+  }
+  return co(i);
+}
+function Do(t) {
+  function r(n, a) {
+    return a === void 0 && (a = {}), Mo(t(n, a));
+  }
+  var e = /* @__PURE__ */ new Map();
+  return new Proxy(r, {
+    /**
+     * 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 e.has(a) || e.set(a, r(a)), e.get(a);
+    }
+  });
+}
+var Ro = [
+  "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 ae(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
+       */
+      !!(Ro.indexOf(t) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/.test(t))
+    )
+  );
+}
+var Et = {};
+function Oo(t) {
+  for (var r in t)
+    Et[r] = t[r];
+}
+var Io = ["", "X", "Y", "Z"], Bo = ["translate", "scale", "rotate", "skew"], Bt = ["transformPerspective", "x", "y", "z"];
+Bo.forEach(function(t) {
+  return Io.forEach(function(r) {
+    return Bt.push(t + r);
+  });
+});
+function Fo(t, r) {
+  return Bt.indexOf(t) - Bt.indexOf(r);
+}
+var jo = new Set(Bt);
+function Vr(t) {
+  return jo.has(t);
+}
+var Ho = /* @__PURE__ */ new Set(["originX", "originY", "originZ"]);
+function Bn(t) {
+  return Ho.has(t);
+}
+function Fn(t, r) {
+  var e = r.layout, n = r.layoutId;
+  return Vr(t) || Bn(t) || (e || n !== void 0) && (!!Et[t] || t === "opacity");
+}
+var st = function(t) {
+  return t !== null && typeof t == "object" && t.getVelocity;
+}, Uo = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+};
+function No(t, r, e, n) {
+  var a = t.transform, o = t.transformKeys, i = r.enableHardwareAcceleration, u = i === void 0 ? !0 : i, f = r.allowTransformNone, s = f === void 0 ? !0 : f, l = "";
+  o.sort(Fo);
+  for (var m = !1, v = o.length, d = 0; d < v; d++) {
+    var c = o[d];
+    l += (Uo[c] || c) + "(" + a[c] + ") ", c === "z" && (m = !0);
+  }
+  return !m && u ? l += "translateZ(0)" : l = l.trim(), n ? l = n(a, e ? "" : l) : s && e && (l = "none"), l;
+}
+function _o(t) {
+  var r = t.originX, e = r === void 0 ? "50%" : r, n = t.originY, a = n === void 0 ? "50%" : n, o = t.originZ, i = o === void 0 ? 0 : o;
+  return e + " " + a + " " + i;
+}
+function jn(t) {
+  return t.startsWith("--");
+}
+var Ko = function(t, r) {
+  return r && typeof t == "number" ? r.transform(t) : t;
+}, Hn = function(t, r) {
+  return function(e) {
+    return Math.max(Math.min(e, r), t);
+  };
+}, Mt = function(t) {
+  return t % 1 ? Number(t.toFixed(5)) : t;
+}, Ft = /(-)?([\d]*\.?[\d])+/g, Hr = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\((-?[\d\.]+%?[,\s]+){2,3}\s*\/*\s*[\d\.]+%?\))/gi, zo = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\((-?[\d\.]+%?[,\s]+){2,3}\s*\/*\s*[\d\.]+%?\))$/i;
+function Yt(t) {
+  return typeof t == "string";
+}
+var gt = {
+  test: function(t) {
+    return typeof t == "number";
+  },
+  parse: parseFloat,
+  transform: function(t) {
+    return t;
+  }
+}, Dt = h(h({}, gt), { transform: Hn(0, 1) }), Jt = h(h({}, gt), { default: 1 }), Gt = function(t) {
+  return {
+    test: function(r) {
+      return Yt(r) && r.endsWith(t) && r.split(" ").length === 1;
+    },
+    parse: parseFloat,
+    transform: function(r) {
+      return "" + r + t;
+    }
+  };
+}, ut = Gt("deg"), At = Gt("%"), E = Gt("px"), Yo = Gt("vh"), Go = Gt("vw"), we = h(h({}, At), { parse: function(t) {
+  return At.parse(t) / 100;
+}, transform: function(t) {
+  return At.transform(t * 100);
+} }), oe = function(t, r) {
+  return function(e) {
+    return !!(Yt(e) && zo.test(e) && e.startsWith(t) || r && Object.prototype.hasOwnProperty.call(e, r));
+  };
+}, Un = function(t, r, e) {
+  return function(n) {
+    var a;
+    if (!Yt(n))
+      return n;
+    var o = n.match(Ft), i = o[0], u = o[1], f = o[2], s = o[3];
+    return a = {}, a[t] = parseFloat(i), a[r] = parseFloat(u), a[e] = parseFloat(f), a.alpha = s !== void 0 ? parseFloat(s) : 1, a;
+  };
+}, Pt = {
+  test: oe("hsl", "hue"),
+  parse: Un("hue", "saturation", "lightness"),
+  transform: function(t) {
+    var r = t.hue, e = t.saturation, n = t.lightness, a = t.alpha, o = a === void 0 ? 1 : a;
+    return "hsla(" + Math.round(r) + ", " + At.transform(Mt(e)) + ", " + At.transform(Mt(n)) + ", " + Mt(Dt.transform(o)) + ")";
+  }
+}, Xo = Hn(0, 255), Dr = h(h({}, gt), { transform: function(t) {
+  return Math.round(Xo(t));
+} }), xt = {
+  test: oe("rgb", "red"),
+  parse: Un("red", "green", "blue"),
+  transform: function(t) {
+    var r = t.red, e = t.green, n = t.blue, a = t.alpha, o = a === void 0 ? 1 : a;
+    return "rgba(" + Dr.transform(r) + ", " + Dr.transform(e) + ", " + Dr.transform(n) + ", " + Mt(Dt.transform(o)) + ")";
+  }
+};
+function Wo(t) {
+  var r = "", e = "", n = "", a = "";
+  return t.length > 5 ? (r = t.substr(1, 2), e = t.substr(3, 2), n = t.substr(5, 2), a = t.substr(7, 2)) : (r = t.substr(1, 1), e = t.substr(2, 1), n = t.substr(3, 1), a = t.substr(4, 1), r += r, e += e, n += n, a += a), {
+    red: parseInt(r, 16),
+    green: parseInt(e, 16),
+    blue: parseInt(n, 16),
+    alpha: a ? parseInt(a, 16) / 255 : 1
+  };
+}
+var Ur = {
+  test: oe("#"),
+  parse: Wo,
+  transform: xt.transform
+}, Y = {
+  test: function(t) {
+    return xt.test(t) || Ur.test(t) || Pt.test(t);
+  },
+  parse: function(t) {
+    return xt.test(t) ? xt.parse(t) : Pt.test(t) ? Pt.parse(t) : Ur.parse(t);
+  },
+  transform: function(t) {
+    return Yt(t) ? t : t.hasOwnProperty("red") ? xt.transform(t) : Pt.transform(t);
+  }
+}, Nn = "${c}", _n = "${n}";
+function Zo(t) {
+  var r, e, n, a;
+  return isNaN(t) && Yt(t) && ((e = (r = t.match(Ft)) === null || r === void 0 ? void 0 : r.length) !== null && e !== void 0 ? e : 0) + ((a = (n = t.match(Hr)) === null || n === void 0 ? void 0 : n.length) !== null && a !== void 0 ? a : 0) > 0;
+}
+function Kn(t) {
+  var r = [], e = 0, n = t.match(Hr);
+  n && (e = n.length, t = t.replace(Hr, Nn), r.push.apply(r, n.map(Y.parse)));
+  var a = t.match(Ft);
+  return a && (t = t.replace(Ft, _n), r.push.apply(r, a.map(gt.parse))), { values: r, numColors: e, tokenised: t };
+}
+function zn(t) {
+  return Kn(t).values;
+}
+function Yn(t) {
+  var r = Kn(t), e = r.values, n = r.numColors, a = r.tokenised, o = e.length;
+  return function(i) {
+    for (var u = a, f = 0; f < o; f++)
+      u = u.replace(f < n ? Nn : _n, f < n ? Y.transform(i[f]) : Mt(i[f]));
+    return u;
+  };
+}
+var $o = function(t) {
+  return typeof t == "number" ? 0 : t;
+};
+function qo(t) {
+  var r = zn(t), e = Yn(t);
+  return e(r.map($o));
+}
+var it = { test: Zo, parse: zn, createTransformer: Yn, getAnimatableNone: qo }, Jo = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function Qo(t) {
+  var r = t.slice(0, -1).split("("), e = r[0], n = r[1];
+  if (e === "drop-shadow")
+    return t;
+  var a = (n.match(Ft) || [])[0];
+  if (!a)
+    return t;
+  var o = n.replace(a, ""), i = Jo.has(e) ? 1 : 0;
+  return a !== n && (i *= 100), e + "(" + i + o + ")";
+}
+var ko = /([a-z-]*)\(.*?\)/g, Nr = h(h({}, it), { getAnimatableNone: function(t) {
+  var r = t.match(ko);
+  return r ? r.map(Qo).join(" ") : t;
+} }), Ee = h(h({}, gt), { transform: Math.round }), Gn = {
+  // Border props
+  borderWidth: E,
+  borderTopWidth: E,
+  borderRightWidth: E,
+  borderBottomWidth: E,
+  borderLeftWidth: E,
+  borderRadius: E,
+  radius: E,
+  borderTopLeftRadius: E,
+  borderTopRightRadius: E,
+  borderBottomRightRadius: E,
+  borderBottomLeftRadius: E,
+  // Positioning props
+  width: E,
+  maxWidth: E,
+  height: E,
+  maxHeight: E,
+  size: E,
+  top: E,
+  right: E,
+  bottom: E,
+  left: E,
+  // Spacing props
+  padding: E,
+  paddingTop: E,
+  paddingRight: E,
+  paddingBottom: E,
+  paddingLeft: E,
+  margin: E,
+  marginTop: E,
+  marginRight: E,
+  marginBottom: E,
+  marginLeft: E,
+  // Transform props
+  rotate: ut,
+  rotateX: ut,
+  rotateY: ut,
+  rotateZ: ut,
+  scale: Jt,
+  scaleX: Jt,
+  scaleY: Jt,
+  scaleZ: Jt,
+  skew: ut,
+  skewX: ut,
+  skewY: ut,
+  distance: E,
+  translateX: E,
+  translateY: E,
+  translateZ: E,
+  x: E,
+  y: E,
+  z: E,
+  perspective: E,
+  transformPerspective: E,
+  opacity: Dt,
+  originX: we,
+  originY: we,
+  originZ: E,
+  // Misc
+  zIndex: Ee,
+  // SVG
+  fillOpacity: Dt,
+  strokeOpacity: Dt,
+  numOctaves: Ee
+};
+function ie(t, r, e, n, a, o, i, u) {
+  var f, s = t.style, l = t.vars, m = t.transform, v = t.transformKeys, d = t.transformOrigin;
+  v.length = 0;
+  var c = !1, y = !1, p = !0;
+  for (var g in r) {
+    var S = r[g];
+    if (jn(g)) {
+      l[g] = S;
+      continue;
+    }
+    var M = Gn[g], L = Ko(S, M);
+    if (Vr(g)) {
+      if (c = !0, m[g] = L, v.push(g), !p)
+        continue;
+      S !== ((f = M.default) !== null && f !== void 0 ? f : 0) && (p = !1);
+    } else if (Bn(g))
+      d[g] = L, y = !0;
+    else if (e != null && e.isHydrated && (n != null && n.isHydrated) && Et[g]) {
+      var x = Et[g].process(S, n, e), T = Et[g].applyTo;
+      if (T)
+        for (var w = T.length, C = 0; C < w; C++)
+          s[T[C]] = x;
+      else
+        s[g] = x;
+    } else
+      s[g] = L;
+  }
+  n && e && i && u ? (s.transform = i(n.deltaFinal, n.treeScale, c ? m : void 0), o && (s.transform = o(m, s.transform)), s.transformOrigin = u(n)) : (c && (s.transform = No(t, a, p, o)), y && (s.transformOrigin = _o(d)));
+}
+var ue = function() {
+  return {
+    style: {},
+    transform: {},
+    transformKeys: [],
+    transformOrigin: {},
+    vars: {}
+  };
+};
+function Xn(t, r, e) {
+  for (var n in r)
+    !st(r[n]) && !Fn(n, e) && (t[n] = r[n]);
+}
+function ti(t, r, e) {
+  var n = t.transformTemplate;
+  return re(function() {
+    var a = ue();
+    ie(a, r, void 0, void 0, { enableHardwareAcceleration: !e }, n);
+    var o = a.vars, i = a.style;
+    return h(h({}, o), i);
+  }, [r]);
+}
+function ri(t, r, e) {
+  var n = t.style || {}, a = {};
+  return Xn(a, n, t), Object.assign(a, ti(t, r, e)), t.transformValues && (a = t.transformValues(a)), a;
+}
+function ei(t, r, e) {
+  var n = {}, a = ri(t, r, e);
+  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 ni = /* @__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 fr(t) {
+  return ni.has(t);
+}
+var Wn = function(t) {
+  return !fr(t);
+};
+try {
+  var ai = require("@emotion/is-prop-valid").default;
+  Wn = function(t) {
+    return t.startsWith("on") ? !fr(t) : ai(t);
+  };
+} catch {
+}
+function oi(t, r, e) {
+  var n = {};
+  for (var a in t)
+    (Wn(a) || e === !0 && fr(a) || !r && !fr(a)) && (n[a] = t[a]);
+  return n;
+}
+function Me(t, r, e) {
+  return typeof t == "string" ? t : E.transform(r + e * t);
+}
+function ii(t, r, e) {
+  var n = Me(r, t.x, t.width), a = Me(e, t.y, t.height);
+  return n + " " + a;
+}
+var Rr = function(t, r) {
+  return E.transform(t * r);
+}, ui = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function si(t, r, e, n, a, o) {
+  n === void 0 && (n = 1), a === void 0 && (a = 0);
+  var i = ui;
+  t[i.offset] = Rr(-a, r);
+  var u = Rr(e, r), f = Rr(n, r);
+  t[i.array] = u + " " + f;
+}
+function se(t, r, e, n, a, o, i, u) {
+  var f = r.attrX, s = r.attrY, l = r.originX, m = r.originY, v = r.pathLength, d = r.pathSpacing, c = d === void 0 ? 1 : d, y = r.pathOffset, p = y === void 0 ? 0 : y, g = J(r, ["attrX", "attrY", "originX", "originY", "pathLength", "pathSpacing", "pathOffset"]);
+  ie(t, g, e, n, a, o, i, u), t.attrs = t.style, t.style = {};
+  var S = t.attrs, M = t.style, L = t.dimensions, x = t.totalPathLength;
+  S.transform && (L && (M.transform = S.transform), delete S.transform), L && (l !== void 0 || m !== void 0 || M.transform) && (M.transformOrigin = ii(L, l !== void 0 ? l : 0.5, m !== void 0 ? m : 0.5)), f !== void 0 && (S.x = f), s !== void 0 && (S.y = s), x !== void 0 && v !== void 0 && si(S, x, v, c, p);
+}
+var Zn = function() {
+  return h(h({}, ue()), { attrs: {} });
+};
+function fi(t, r) {
+  var e = re(function() {
+    var a = Zn();
+    return se(a, r, void 0, void 0, { enableHardwareAcceleration: !1 }, t.transformTemplate), h(h({}, a.attrs), { style: h({}, a.style) });
+  }, [r]);
+  if (t.style) {
+    var n = {};
+    Xn(n, t.style, t), e.style = h(h({}, n), e.style);
+  }
+  return e;
+}
+function li(t) {
+  t === void 0 && (t = !1);
+  var r = function(e, n, a, o, i) {
+    var u = o.latestValues, f = ae(e) ? fi : ei, s = f(n, u, i), l = oi(n, typeof e == "string", t), m = h(h(h({}, l), s), { ref: a });
+    return vo(e, m);
+  };
+  return r;
+}
+var ci = /([a-z])([A-Z])/g, vi = "$1-$2", $n = function(t) {
+  return t.replace(ci, vi).toLowerCase();
+};
+function qn(t, r) {
+  var e = r.style, n = r.vars;
+  Object.assign(t.style, e);
+  for (var a in n)
+    t.style.setProperty(a, n[a]);
+}
+var Jn = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform"
+]);
+function Qn(t, r) {
+  qn(t, r);
+  for (var e in r.attrs)
+    t.setAttribute(Jn.has(e) ? e : $n(e), r.attrs[e]);
+}
+function fe(t) {
+  var r = t.style, e = {};
+  for (var n in r)
+    (st(r[n]) || Fn(n, t)) && (e[n] = r[n]);
+  return e;
+}
+function kn(t) {
+  var r = fe(t);
+  for (var e in t)
+    if (st(t[e])) {
+      var n = e === "x" || e === "y" ? "attr" + e.toUpperCase() : e;
+      r[n] = t[e];
+    }
+  return r;
+}
+function le(t) {
+  return typeof t == "object" && typeof t.start == "function";
+}
+var jt = function(t) {
+  return Array.isArray(t);
+}, di = function(t) {
+  return !!(t && typeof t == "object" && t.mix && t.toValue);
+}, mi = function(t) {
+  return jt(t) ? t[t.length - 1] || 0 : t;
+};
+function pi(t) {
+  var r = st(t) ? t.get() : t;
+  return di(r) ? r.toValue() : r;
+}
+function De(t, r, e, n) {
+  var a = t.scrapeMotionValuesFromProps, o = t.createRenderState, i = t.onMount, u = {
+    latestValues: gi(r, e, n, a),
+    renderState: o()
+  };
+  return i && (u.mount = function(f) {
+    return i(r, f, u);
+  }), u;
+}
+var ta = function(t) {
+  return function(r, e) {
+    var n = z(xr), a = z(Tr);
+    return e ? De(t, r, n, a) : ne(function() {
+      return De(t, r, n, a);
+    });
+  };
+};
+function gi(t, r, e, n) {
+  var a = {}, o = (e == null ? void 0 : e.initial) === !1, i = n(t);
+  for (var u in i)
+    a[u] = pi(i[u]);
+  var f = t.initial, s = t.animate, l = Ar(t), m = In(t);
+  r && m && !l && t.inherit !== !1 && (f ?? (f = r.initial), s ?? (s = r.animate));
+  var v = o || f === !1 ? s : f;
+  if (v && typeof v != "boolean" && !le(v)) {
+    var d = Array.isArray(v) ? v : [v];
+    d.forEach(function(c) {
+      var y = On(t, c);
+      if (y) {
+        var p = y.transitionEnd;
+        y.transition;
+        var g = J(y, ["transitionEnd", "transition"]);
+        for (var S in g)
+          a[S] = g[S];
+        for (var S in p)
+          a[S] = p[S];
+      }
+    });
+  }
+  return a;
+}
+var hi = {
+  useVisualState: ta({
+    scrapeMotionValuesFromProps: kn,
+    createRenderState: Zn,
+    onMount: function(t, r, e) {
+      var n = e.renderState, a = e.latestValues;
+      try {
+        n.dimensions = typeof r.getBBox == "function" ? r.getBBox() : r.getBoundingClientRect();
+      } catch {
+        n.dimensions = {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        };
+      }
+      yi(r) && (n.totalPathLength = r.getTotalLength()), se(n, a, void 0, void 0, { enableHardwareAcceleration: !1 }, t.transformTemplate), Qn(r, n);
+    }
+  })
+};
+function yi(t) {
+  return t.tagName === "path";
+}
+var bi = {
+  useVisualState: ta({
+    scrapeMotionValuesFromProps: fe,
+    createRenderState: ue
+  })
+};
+function Pi(t, r, e, n) {
+  var a = r.forwardMotionProps, o = a === void 0 ? !1 : a, i = ae(t) ? hi : bi;
+  return h(h({}, i), {
+    preloadedFeatures: e,
+    useRender: li(o),
+    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 ce(t, r, e, n) {
+  return t.addEventListener(r, e, n), function() {
+    return t.removeEventListener(r, e, n);
+  };
+}
+function _r(t, r, e, n) {
+  at(function() {
+    var a = t.current;
+    if (e && a)
+      return ce(a, r, e, n);
+  }, [t, r, e, n]);
+}
+function xi(t) {
+  var r = t.whileFocus, e = t.visualElement, n = function() {
+    var o;
+    (o = e.animationState) === null || o === void 0 || o.setActive(F.Focus, !0);
+  }, a = function() {
+    var o;
+    (o = e.animationState) === null || o === void 0 || o.setActive(F.Focus, !1);
+  };
+  _r(e, "focus", r ? n : void 0), _r(e, "blur", r ? a : void 0);
+}
+function ra(t) {
+  return typeof PointerEvent < "u" && t instanceof PointerEvent ? t.pointerType === "mouse" : t instanceof MouseEvent;
+}
+function ea(t) {
+  var r = !!t.touches;
+  return r;
+}
+function Ti(t) {
+  return function(r) {
+    var e = r instanceof MouseEvent, n = !e || e && r.button === 0;
+    n && t(r);
+  };
+}
+var Si = { pageX: 0, pageY: 0 };
+function Ai(t, r) {
+  r === void 0 && (r = "page");
+  var e = t.touches[0] || t.changedTouches[0], n = e || Si;
+  return {
+    x: n[r + "X"],
+    y: n[r + "Y"]
+  };
+}
+function Vi(t, r) {
+  return r === void 0 && (r = "page"), {
+    x: t[r + "X"],
+    y: t[r + "Y"]
+  };
+}
+function ve(t, r) {
+  return r === void 0 && (r = "page"), {
+    point: ea(t) ? Ai(t, r) : Vi(t, r)
+  };
+}
+function Ci(t) {
+  return ve(t, "client");
+}
+var na = function(t, r) {
+  r === void 0 && (r = !1);
+  var e = function(n) {
+    return t(n, ve(n));
+  };
+  return r ? Ti(e) : e;
+}, Li = function() {
+  return zt && window.onpointerdown === null;
+}, wi = function() {
+  return zt && window.ontouchstart === null;
+}, Ei = function() {
+  return zt && window.onmousedown === null;
+}, Mi = {
+  pointerdown: "mousedown",
+  pointermove: "mousemove",
+  pointerup: "mouseup",
+  pointercancel: "mousecancel",
+  pointerover: "mouseover",
+  pointerout: "mouseout",
+  pointerenter: "mouseenter",
+  pointerleave: "mouseleave"
+}, Di = {
+  pointerdown: "touchstart",
+  pointermove: "touchmove",
+  pointerup: "touchend",
+  pointercancel: "touchcancel"
+};
+function aa(t) {
+  return Li() ? t : wi() ? Di[t] : Ei() ? Mi[t] : t;
+}
+function Vt(t, r, e, n) {
+  return ce(t, aa(r), na(e, r === "pointerdown"), n);
+}
+function lr(t, r, e, n) {
+  return _r(t, aa(r), e && na(e, r === "pointerdown"), n);
+}
+function oa(t) {
+  var r = null;
+  return function() {
+    var e = function() {
+      r = null;
+    };
+    return r === null ? (r = t, e) : !1;
+  };
+}
+var Re = oa("dragHorizontal"), Oe = oa("dragVertical");
+function ia(t) {
+  var r = !1;
+  if (t === "y")
+    r = Oe();
+  else if (t === "x")
+    r = Re();
+  else {
+    var e = Re(), n = Oe();
+    e && n ? r = function() {
+      e(), n();
+    } : (e && e(), n && n());
+  }
+  return r;
+}
+function ua() {
+  var t = ia(!0);
+  return t ? (t(), !1) : !0;
+}
+function Ie(t, r, e) {
+  return function(n, a) {
+    var o;
+    !ra(n) || ua() || (e == null || e(n, a), (o = t.animationState) === null || o === void 0 || o.setActive(F.Hover, r));
+  };
+}
+function Ri(t) {
+  var r = t.onHoverStart, e = t.onHoverEnd, n = t.whileHover, a = t.visualElement;
+  lr(a, "pointerenter", r || n ? Ie(a, !0, r) : void 0), lr(a, "pointerleave", e || n ? Ie(a, !1, e) : void 0);
+}
+var sa = function(t, r) {
+  return r ? t === r ? !0 : sa(t, r.parentElement) : !1;
+};
+function fa(t) {
+  return at(function() {
+    return function() {
+      return t();
+    };
+  }, []);
+}
+var cr = function(t, r, e) {
+  return Math.min(Math.max(e, t), r);
+}, Or = 1e-3, Oi = 0.01, Be = 10, Ii = 0.05, Bi = 1;
+function Fi(t) {
+  var r = t.duration, e = r === void 0 ? 800 : r, n = t.bounce, a = n === void 0 ? 0.25 : n, o = t.velocity, i = o === void 0 ? 0 : o, u = t.mass, f = u === void 0 ? 1 : u, s, l;
+  br(e <= Be * 1e3, "Spring duration must be 10 seconds or less");
+  var m = 1 - a;
+  m = cr(Ii, Bi, m), e = cr(Oi, Be, e / 1e3), m < 1 ? (s = function(y) {
+    var p = y * m, g = p * e, S = p - i, M = Kr(y, m), L = Math.exp(-g);
+    return Or - S / M * L;
+  }, l = function(y) {
+    var p = y * m, g = p * e, S = g * i + i, M = Math.pow(m, 2) * Math.pow(y, 2) * e, L = Math.exp(-g), x = Kr(Math.pow(y, 2), m), T = -s(y) + Or > 0 ? -1 : 1;
+    return T * ((S - M) * L) / x;
+  }) : (s = function(y) {
+    var p = Math.exp(-y * e), g = (y - i) * e + 1;
+    return -Or + p * g;
+  }, l = function(y) {
+    var p = Math.exp(-y * e), g = (i - y) * (e * e);
+    return p * g;
+  });
+  var v = 5 / e, d = Hi(s, l, v);
+  if (e = e * 1e3, isNaN(d))
+    return {
+      stiffness: 100,
+      damping: 10,
+      duration: e
+    };
+  var c = Math.pow(d, 2) * f;
+  return {
+    stiffness: c,
+    damping: m * 2 * Math.sqrt(f * c),
+    duration: e
+  };
+}
+var ji = 12;
+function Hi(t, r, e) {
+  for (var n = e, a = 1; a < ji; a++)
+    n = n - t(n) / r(n);
+  return n;
+}
+function Kr(t, r) {
+  return t * Math.sqrt(1 - r * r);
+}
+var Ui = ["duration", "bounce"], Ni = ["stiffness", "damping", "mass"];
+function Fe(t, r) {
+  return r.some(function(e) {
+    return t[e] !== void 0;
+  });
+}
+function _i(t) {
+  var r = h({ velocity: 0, stiffness: 100, damping: 10, mass: 1, isResolvedFromDuration: !1 }, t);
+  if (!Fe(t, Ni) && Fe(t, Ui)) {
+    var e = Fi(t);
+    r = h(h(h({}, r), e), { velocity: 0, mass: 1 }), r.isResolvedFromDuration = !0;
+  }
+  return r;
+}
+function de(t) {
+  var r = t.from, e = r === void 0 ? 0 : r, n = t.to, a = n === void 0 ? 1 : n, o = t.restSpeed, i = o === void 0 ? 2 : o, u = t.restDelta, f = J(t, ["from", "to", "restSpeed", "restDelta"]), s = { done: !1, value: e }, l = _i(f), m = l.stiffness, v = l.damping, d = l.mass, c = l.velocity, y = l.duration, p = l.isResolvedFromDuration, g = je, S = je;
+  function M() {
+    var L = c ? -(c / 1e3) : 0, x = a - e, T = v / (2 * Math.sqrt(m * d)), w = Math.sqrt(m / d) / 1e3;
+    if (u ?? (u = Math.abs(a - e) <= 1 ? 0.01 : 0.4), T < 1) {
+      var C = Kr(w, T);
+      g = function(D) {
+        var R = Math.exp(-T * w * D);
+        return a - R * ((L + T * w * x) / C * Math.sin(C * D) + x * Math.cos(C * D));
+      }, S = function(D) {
+        var R = Math.exp(-T * w * D);
+        return T * w * R * (Math.sin(C * D) * (L + T * w * x) / C + x * Math.cos(C * D)) - R * (Math.cos(C * D) * (L + T * w * x) - C * x * Math.sin(C * D));
+      };
+    } else if (T === 1)
+      g = function(D) {
+        return a - Math.exp(-w * D) * (x + (L + w * x) * D);
+      };
+    else {
+      var A = w * Math.sqrt(T * T - 1);
+      g = function(D) {
+        var R = Math.exp(-T * w * D), j = Math.min(A * D, 300);
+        return a - R * ((L + T * w * x) * Math.sinh(j) + A * x * Math.cosh(j)) / A;
+      };
+    }
+  }
+  return M(), {
+    next: function(L) {
+      var x = g(L);
+      if (p)
+        s.done = L >= y;
+      else {
+        var T = S(L) * 1e3, w = Math.abs(T) <= i, C = Math.abs(a - x) <= u;
+        s.done = w && C;
+      }
+      return s.value = s.done ? a : x, s;
+    },
+    flipTarget: function() {
+      var L;
+      c = -c, L = [a, e], e = L[0], a = L[1], M();
+    }
+  };
+}
+de.needsInterpolation = function(t, r) {
+  return typeof t == "string" || typeof r == "string";
+};
+var je = function(t) {
+  return 0;
+}, Ht = function(t, r, e) {
+  var n = r - t;
+  return n === 0 ? 1 : (e - t) / n;
+}, Z = function(t, r, e) {
+  return -e * t + e * r + t;
+}, Ki = function(t, r, e) {
+  var n = t * t, a = r * r;
+  return Math.sqrt(Math.max(0, e * (a - n) + n));
+}, zi = [Ur, xt, Pt], He = function(t) {
+  return zi.find(function(r) {
+    return r.test(t);
+  });
+}, Ue = function(t) {
+  return "'" + t + "' is not an animatable color. Use the equivalent color code instead.";
+}, la = function(t, r) {
+  var e = He(t), n = He(r);
+  X(!!e, Ue(t)), X(!!n, Ue(r)), X(e.transform === n.transform, "Both colors must be hex/RGBA, OR both must be HSLA.");
+  var a = e.parse(t), o = n.parse(r), i = h({}, a), u = e === Pt ? Z : Ki;
+  return function(f) {
+    for (var s in i)
+      s !== "alpha" && (i[s] = u(a[s], o[s], f));
+    return i.alpha = Z(a.alpha, o.alpha, f), e.transform(i);
+  };
+}, zr = function(t) {
+  return typeof t == "number";
+}, Yi = function(t, r) {
+  return function(e) {
+    return r(t(e));
+  };
+}, Xt = function() {
+  for (var t = [], r = 0; r < arguments.length; r++)
+    t[r] = arguments[r];
+  return t.reduce(Yi);
+};
+function ca(t, r) {
+  return zr(t) ? function(e) {
+    return Z(t, r, e);
+  } : Y.test(t) ? la(t, r) : da(t, r);
+}
+var va = function(t, r) {
+  var e = W([], t), n = e.length, a = t.map(function(o, i) {
+    return ca(o, r[i]);
+  });
+  return function(o) {
+    for (var i = 0; i < n; i++)
+      e[i] = a[i](o);
+    return e;
+  };
+}, Gi = function(t, r) {
+  var e = h(h({}, t), r), n = {};
+  for (var a in e)
+    t[a] !== void 0 && r[a] !== void 0 && (n[a] = ca(t[a], r[a]));
+  return function(o) {
+    for (var i in n)
+      e[i] = n[i](o);
+    return e;
+  };
+};
+function Ne(t) {
+  for (var r = it.parse(t), e = r.length, n = 0, a = 0, o = 0, i = 0; i < e; i++)
+    n || typeof r[i] == "number" ? n++ : r[i].hue !== void 0 ? o++ : a++;
+  return { parsed: r, numNumbers: n, numRGB: a, numHSL: o };
+}
+var da = function(t, r) {
+  var e = it.createTransformer(r), n = Ne(t), a = Ne(r);
+  return X(n.numHSL === a.numHSL && n.numRGB === a.numRGB && n.numNumbers >= a.numNumbers, "Complex values '" + t + "' and '" + r + "' too different to mix. Ensure all colors are of the same type."), Xt(va(n.parsed, a.parsed), e);
+}, Xi = function(t, r) {
+  return function(e) {
+    return Z(t, r, e);
+  };
+};
+function Wi(t) {
+  if (typeof t == "number")
+    return Xi;
+  if (typeof t == "string")
+    return Y.test(t) ? la : da;
+  if (Array.isArray(t))
+    return va;
+  if (typeof t == "object")
+    return Gi;
+}
+function Zi(t, r, e) {
+  for (var n = [], a = e || Wi(t[0]), o = t.length - 1, i = 0; i < o; i++) {
+    var u = a(t[i], t[i + 1]);
+    if (r) {
+      var f = Array.isArray(r) ? r[i] : r;
+      u = Xt(f, u);
+    }
+    n.push(u);
+  }
+  return n;
+}
+function $i(t, r) {
+  var e = t[0], n = t[1], a = r[0];
+  return function(o) {
+    return a(Ht(e, n, o));
+  };
+}
+function qi(t, r) {
+  var e = t.length, n = e - 1;
+  return function(a) {
+    var o = 0, i = !1;
+    if (a <= t[0] ? i = !0 : a >= t[n] && (o = n - 1, i = !0), !i) {
+      for (var u = 1; u < e && !(t[u] > a || u === n); u++)
+        ;
+      o = u - 1;
+    }
+    var f = Ht(t[o], t[o + 1], a);
+    return r[o](f);
+  };
+}
+function ma(t, r, e) {
+  var n = e === void 0 ? {} : e, a = n.clamp, o = a === void 0 ? !0 : a, i = n.ease, u = n.mixer, f = t.length;
+  X(f === r.length, "Both input and output ranges must be the same length"), X(!i || !Array.isArray(i) || i.length === f - 1, "Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values."), t[0] > t[f - 1] && (t = [].concat(t), r = [].concat(r), t.reverse(), r.reverse());
+  var s = Zi(r, i, u), l = f === 2 ? $i(t, s) : qi(t, s);
+  return o ? function(m) {
+    return l(cr(t[0], t[f - 1], m));
+  } : l;
+}
+var Cr = function(t) {
+  return function(r) {
+    return 1 - t(1 - r);
+  };
+}, me = function(t) {
+  return function(r) {
+    return r <= 0.5 ? t(2 * r) / 2 : (2 - t(2 * (1 - r))) / 2;
+  };
+}, Ji = function(t) {
+  return function(r) {
+    return Math.pow(r, t);
+  };
+}, pa = function(t) {
+  return function(r) {
+    return r * r * ((t + 1) * r - t);
+  };
+}, Qi = function(t) {
+  var r = pa(t);
+  return function(e) {
+    return (e *= 2) < 1 ? 0.5 * r(e) : 0.5 * (2 - Math.pow(2, -10 * (e - 1)));
+  };
+}, ga = 1.525, ki = 4 / 11, tu = 8 / 11, ru = 9 / 10, ha = function(t) {
+  return t;
+}, pe = Ji(2), eu = Cr(pe), ya = me(pe), ba = function(t) {
+  return 1 - Math.sin(Math.acos(t));
+}, Pa = Cr(ba), nu = me(Pa), ge = pa(ga), au = Cr(ge), ou = me(ge), iu = Qi(ga), uu = 4356 / 361, su = 35442 / 1805, fu = 16061 / 1805, vr = function(t) {
+  if (t === 1 || t === 0)
+    return t;
+  var r = t * t;
+  return t < ki ? 7.5625 * r : t < tu ? 9.075 * r - 9.9 * t + 3.4 : t < ru ? uu * r - su * t + fu : 10.8 * t * t - 20.52 * t + 10.72;
+}, lu = Cr(vr), cu = function(t) {
+  return t < 0.5 ? 0.5 * (1 - vr(1 - t * 2)) : 0.5 * vr(t * 2 - 1) + 0.5;
+};
+function vu(t, r) {
+  return t.map(function() {
+    return r || ya;
+  }).splice(0, t.length - 1);
+}
+function du(t) {
+  var r = t.length;
+  return t.map(function(e, n) {
+    return n !== 0 ? n / (r - 1) : 0;
+  });
+}
+function mu(t, r) {
+  return t.map(function(e) {
+    return e * r;
+  });
+}
+function or(t) {
+  var r = t.from, e = r === void 0 ? 0 : r, n = t.to, a = n === void 0 ? 1 : n, o = t.ease, i = t.offset, u = t.duration, f = u === void 0 ? 300 : u, s = { done: !1, value: e }, l = Array.isArray(a) ? a : [e, a], m = mu(i && i.length === l.length ? i : du(l), f);
+  function v() {
+    return ma(m, l, {
+      ease: Array.isArray(o) ? o : vu(l, o)
+    });
+  }
+  var d = v();
+  return {
+    next: function(c) {
+      return s.value = d(c), s.done = c >= f, s;
+    },
+    flipTarget: function() {
+      l.reverse(), d = v();
+    }
+  };
+}
+function pu(t) {
+  var r = t.velocity, e = r === void 0 ? 0 : r, n = t.from, a = n === void 0 ? 0 : n, o = t.power, i = o === void 0 ? 0.8 : o, u = t.timeConstant, f = u === void 0 ? 350 : u, s = t.restDelta, l = s === void 0 ? 0.5 : s, m = t.modifyTarget, v = { done: !1, value: a }, d = i * e, c = a + d, y = m === void 0 ? c : m(c);
+  return y !== c && (d = y - a), {
+    next: function(p) {
+      var g = -d * Math.exp(-p / f);
+      return v.done = !(g > l || g < -l), v.value = v.done ? y : y + g, v;
+    },
+    flipTarget: function() {
+    }
+  };
+}
+var _e = { keyframes: or, spring: de, decay: pu };
+function gu(t) {
+  if (Array.isArray(t.to))
+    return or;
+  if (_e[t.type])
+    return _e[t.type];
+  var r = new Set(Object.keys(t));
+  return r.has("ease") || r.has("duration") && !r.has("dampingRatio") ? or : r.has("dampingRatio") || r.has("stiffness") || r.has("mass") || r.has("damping") || r.has("restSpeed") || r.has("restDelta") ? de : or;
+}
+var xa = 1 / 60 * 1e3, hu = typeof performance < "u" ? function() {
+  return performance.now();
+} : function() {
+  return Date.now();
+}, Ta = typeof window < "u" ? function(t) {
+  return window.requestAnimationFrame(t);
+} : function(t) {
+  return setTimeout(function() {
+    return t(hu());
+  }, xa);
+};
+function yu(t) {
+  var r = [], e = [], n = 0, a = !1, o = /* @__PURE__ */ new WeakSet(), i = {
+    schedule: function(u, f, s) {
+      f === void 0 && (f = !1), s === void 0 && (s = !1);
+      var l = s && a, m = l ? r : e;
+      return f && o.add(u), m.indexOf(u) === -1 && (m.push(u), l && a && (n = r.length)), u;
+    },
+    cancel: function(u) {
+      var f = e.indexOf(u);
+      f !== -1 && e.splice(f, 1), o.delete(u);
+    },
+    process: function(u) {
+      var f;
+      if (a = !0, f = [e, r], r = f[0], e = f[1], e.length = 0, n = r.length, n)
+        for (var s = 0; s < n; s++) {
+          var l = r[s];
+          l(u), o.has(l) && (i.schedule(l), t());
+        }
+      a = !1;
+    }
+  };
+  return i;
+}
+var bu = 40, Yr = !0, Ut = !1, Gr = !1, Ct = {
+  delta: 0,
+  timestamp: 0
+}, Wt = ["read", "update", "preRender", "render", "postRender"], Lr = /* @__PURE__ */ Wt.reduce(function(t, r) {
+  return t[r] = yu(function() {
+    return Ut = !0;
+  }), t;
+}, {}), nt = /* @__PURE__ */ Wt.reduce(function(t, r) {
+  var e = Lr[r];
+  return t[r] = function(n, a, o) {
+    return a === void 0 && (a = !1), o === void 0 && (o = !1), Ut || xu(), e.schedule(n, a, o);
+  }, t;
+}, {}), Rt = /* @__PURE__ */ Wt.reduce(function(t, r) {
+  return t[r] = Lr[r].cancel, t;
+}, {}), Tt = /* @__PURE__ */ Wt.reduce(function(t, r) {
+  return t[r] = function() {
+    return Lr[r].process(Ct);
+  }, t;
+}, {}), Pu = function(t) {
+  return Lr[t].process(Ct);
+}, Sa = function(t) {
+  Ut = !1, Ct.delta = Yr ? xa : Math.max(Math.min(t - Ct.timestamp, bu), 1), Ct.timestamp = t, Gr = !0, Wt.forEach(Pu), Gr = !1, Ut && (Yr = !1, Ta(Sa));
+}, xu = function() {
+  Ut = !0, Yr = !0, Gr || Ta(Sa);
+}, dr = function() {
+  return Ct;
+};
+function Aa(t, r, e) {
+  return e === void 0 && (e = 0), t - r - e;
+}
+function Tu(t, r, e, n) {
+  return e === void 0 && (e = 0), n === void 0 && (n = !0), n ? Aa(r + -t, r, e) : r - (t - r) + e;
+}
+function Su(t, r, e, n) {
+  return n ? t >= r + e : t <= -e;
+}
+var Au = function(t) {
+  var r = function(e) {
+    var n = e.delta;
+    return t(n);
+  };
+  return {
+    start: function() {
+      return nt.update(r, !0);
+    },
+    stop: function() {
+      return Rt.update(r);
+    }
+  };
+};
+function Va(t) {
+  var r, e, n = t.from, a = t.autoplay, o = a === void 0 ? !0 : a, i = t.driver, u = i === void 0 ? Au : i, f = t.elapsed, s = f === void 0 ? 0 : f, l = t.repeat, m = l === void 0 ? 0 : l, v = t.repeatType, d = v === void 0 ? "loop" : v, c = t.repeatDelay, y = c === void 0 ? 0 : c, p = t.onPlay, g = t.onStop, S = t.onComplete, M = t.onRepeat, L = t.onUpdate, x = J(t, ["from", "autoplay", "driver", "elapsed", "repeat", "repeatType", "repeatDelay", "onPlay", "onStop", "onComplete", "onRepeat", "onUpdate"]), T = x.to, w, C = 0, A = x.duration, D, R = !1, j = !0, U, B = gu(x);
+  !((e = (r = B).needsInterpolation) === null || e === void 0) && e.call(r, n, T) && (U = ma([0, 100], [n, T], {
+    clamp: !1
+  }), n = 0, T = 100);
+  var Q = B(h(h({}, x), { from: n, to: T }));
+  function O() {
+    C++, d === "reverse" ? (j = C % 2 === 0, s = Tu(s, A, y, j)) : (s = Aa(s, A, y), d === "mirror" && Q.flipTarget()), R = !1, M && M();
+  }
+  function $() {
+    w.stop(), S && S();
+  }
+  function q(tt) {
+    if (j || (tt = -tt), s += tt, !R) {
+      var _ = Q.next(Math.max(0, s));
+      D = _.value, U && (D = U(D)), R = j ? _.done : s <= 0;
+    }
+    L == null || L(D), R && (C === 0 && (A ?? (A = s)), C < m ? Su(s, A, y, j) && O() : $());
+  }
+  function ht() {
+    p == null || p(), w = u(q), w.start();
+  }
+  return o && ht(), {
+    stop: function() {
+      g == null || g(), w.stop();
+    }
+  };
+}
+function Ca(t, r) {
+  return r ? t * (1e3 / r) : 0;
+}
+function Vu(t) {
+  var r = t.from, e = r === void 0 ? 0 : r, n = t.velocity, a = n === void 0 ? 0 : n, o = t.min, i = t.max, u = t.power, f = u === void 0 ? 0.8 : u, s = t.timeConstant, l = s === void 0 ? 750 : s, m = t.bounceStiffness, v = m === void 0 ? 500 : m, d = t.bounceDamping, c = d === void 0 ? 10 : d, y = t.restDelta, p = y === void 0 ? 1 : y, g = t.modifyTarget, S = t.driver, M = t.onUpdate, L = t.onComplete, x;
+  function T(O) {
+    return o !== void 0 && O < o || i !== void 0 && O > i;
+  }
+  function w(O) {
+    return o === void 0 ? i : i === void 0 || Math.abs(o - O) < Math.abs(i - O) ? o : i;
+  }
+  function C(O) {
+    x == null || x.stop(), x = Va(h(h({}, O), { driver: S, onUpdate: function($) {
+      var q;
+      M == null || M($), (q = O.onUpdate) === null || q === void 0 || q.call(O, $);
+    }, onComplete: L }));
+  }
+  function A(O) {
+    C(h({ type: "spring", stiffness: v, damping: c, restDelta: p }, O));
+  }
+  if (T(e))
+    A({ from: e, velocity: a, to: w(e) });
+  else {
+    var D = f * a + e;
+    typeof g < "u" && (D = g(D));
+    var R = w(D), j = R === o ? -1 : 1, U, B, Q = function(O) {
+      U = B, B = O, a = Ca(O - U, dr().delta), (j === 1 && O > R || j === -1 && O < R) && A({ from: O, to: R, velocity: a });
+    };
+    C({
+      type: "decay",
+      from: e,
+      velocity: a,
+      timeConstant: l,
+      power: f,
+      restDelta: p,
+      modifyTarget: g,
+      onUpdate: T(D) ? Q : void 0
+    });
+  }
+  return {
+    stop: function() {
+      return x == null ? void 0 : x.stop();
+    }
+  };
+}
+var Xr = function(t) {
+  return t.hasOwnProperty("x") && t.hasOwnProperty("y");
+}, Ke = function(t) {
+  return Xr(t) && t.hasOwnProperty("z");
+}, Qt = function(t, r) {
+  return Math.abs(t - r);
+};
+function La(t, r) {
+  if (zr(t) && zr(r))
+    return Qt(t, r);
+  if (Xr(t) && Xr(r)) {
+    var e = Qt(t.x, r.x), n = Qt(t.y, r.y), a = Ke(t) && Ke(r) ? Qt(t.z, r.z) : 0;
+    return Math.sqrt(Math.pow(e, 2) + Math.pow(n, 2) + Math.pow(a, 2));
+  }
+}
+var wa = function(t, r) {
+  return 1 - 3 * r + 3 * t;
+}, Ea = function(t, r) {
+  return 3 * r - 6 * t;
+}, Ma = function(t) {
+  return 3 * t;
+}, mr = function(t, r, e) {
+  return ((wa(r, e) * t + Ea(r, e)) * t + Ma(r)) * t;
+}, Da = function(t, r, e) {
+  return 3 * wa(r, e) * t * t + 2 * Ea(r, e) * t + Ma(r);
+}, Cu = 1e-7, Lu = 10;
+function wu(t, r, e, n, a) {
+  var o, i, u = 0;
+  do
+    i = r + (e - r) / 2, o = mr(i, n, a) - t, o > 0 ? e = i : r = i;
+  while (Math.abs(o) > Cu && ++u < Lu);
+  return i;
+}
+var Eu = 8, Mu = 1e-3;
+function Du(t, r, e, n) {
+  for (var a = 0; a < Eu; ++a) {
+    var o = Da(r, e, n);
+    if (o === 0)
+      return r;
+    var i = mr(r, e, n) - t;
+    r -= i / o;
+  }
+  return r;
+}
+var ir = 11, kt = 1 / (ir - 1);
+function Ru(t, r, e, n) {
+  if (t === r && e === n)
+    return ha;
+  for (var a = new Float32Array(ir), o = 0; o < ir; ++o)
+    a[o] = mr(o * kt, t, e);
+  function i(u) {
+    for (var f = 0, s = 1, l = ir - 1; s !== l && a[s] <= u; ++s)
+      f += kt;
+    --s;
+    var m = (u - a[s]) / (a[s + 1] - a[s]), v = f + m * kt, d = Da(v, t, e);
+    return d >= Mu ? Du(u, v, t, e) : d === 0 ? v : wu(u, f, f + kt, t, e);
+  }
+  return function(u) {
+    return u === 0 || u === 1 ? u : mr(i(u), r, n);
+  };
+}
+function Ou(t) {
+  var r = t.onTap, e = t.onTapStart, n = t.onTapCancel, a = t.whileTap, o = t.visualElement, i = r || e || n || a, u = It(!1), f = It(null);
+  function s() {
+    var c;
+    (c = f.current) === null || c === void 0 || c.call(f), f.current = null;
+  }
+  function l() {
+    var c;
+    return s(), u.current = !1, (c = o.animationState) === null || c === void 0 || c.setActive(F.Tap, !1), !ua();
+  }
+  function m(c, y) {
+    l() && (sa(o.getInstance(), c.target) ? r == null || r(c, y) : n == null || n(c, y));
+  }
+  function v(c, y) {
+    l() && (n == null || n(c, y));
+  }
+  function d(c, y) {
+    var p;
+    s(), !u.current && (u.current = !0, f.current = Xt(Vt(window, "pointerup", m), Vt(window, "pointercancel", v)), e == null || e(c, y), (p = o.animationState) === null || p === void 0 || p.setActive(F.Tap, !0));
+  }
+  lr(o, "pointerdown", i ? d : void 0), fa(s);
+}
+var dt = function(t) {
+  return function(r) {
+    return t(r), null;
+  };
+}, Iu = {
+  tap: dt(Ou),
+  focus: dt(xi),
+  hover: dt(Ri)
+};
+function Ra(t, r) {
+  if (!Array.isArray(r))
+    return !1;
+  var e = r.length;
+  if (e !== t.length)
+    return !1;
+  for (var n = 0; n < e; n++)
+    if (r[n] !== t[n])
+      return !1;
+  return !0;
+}
+var pr = function(t) {
+  return t * 1e3;
+}, ze = {
+  linear: ha,
+  easeIn: pe,
+  easeInOut: ya,
+  easeOut: eu,
+  circIn: ba,
+  circInOut: nu,
+  circOut: Pa,
+  backIn: ge,
+  backInOut: ou,
+  backOut: au,
+  anticipate: iu,
+  bounceIn: lu,
+  bounceInOut: cu,
+  bounceOut: vr
+}, Ye = function(t) {
+  if (Array.isArray(t)) {
+    X(t.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    var r = H(t, 4), e = r[0], n = r[1], a = r[2], o = r[3];
+    return Ru(e, n, a, o);
+  } else if (typeof t == "string")
+    return X(ze[t] !== void 0, "Invalid easing type '" + t + "'"), ze[t];
+  return t;
+}, Bu = function(t) {
+  return Array.isArray(t) && typeof t[0] != "number";
+}, Ge = function(t, r) {
+  return t === "zIndex" ? !1 : !!(typeof r == "number" || Array.isArray(r) || typeof r == "string" && // It's animatable if we have a string
+  it.test(r) && // And it contains numbers and/or colors
+  !r.startsWith("url("));
+}, vt = function() {
+  return {
+    type: "spring",
+    stiffness: 500,
+    damping: 25,
+    restDelta: 0.5,
+    restSpeed: 10
+  };
+}, tr = function(t) {
+  return {
+    type: "spring",
+    stiffness: 550,
+    damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+    restDelta: 0.01,
+    restSpeed: 10
+  };
+}, Ir = function() {
+  return {
+    type: "keyframes",
+    ease: "linear",
+    duration: 0.3
+  };
+}, Fu = function(t) {
+  return {
+    type: "keyframes",
+    duration: 0.8,
+    values: t
+  };
+}, Xe = {
+  x: vt,
+  y: vt,
+  z: vt,
+  rotate: vt,
+  rotateX: vt,
+  rotateY: vt,
+  rotateZ: vt,
+  scaleX: tr,
+  scaleY: tr,
+  scale: tr,
+  opacity: Ir,
+  backgroundColor: Ir,
+  color: Ir,
+  default: tr
+}, ju = function(t, r) {
+  var e;
+  return jt(r) ? e = Fu : e = Xe[t] || Xe.default, h({ to: r }, e(r));
+}, Hu = h(h({}, Gn), {
+  // Color props
+  color: Y,
+  backgroundColor: Y,
+  outlineColor: Y,
+  fill: Y,
+  stroke: Y,
+  // Border props
+  borderColor: Y,
+  borderTopColor: Y,
+  borderRightColor: Y,
+  borderBottomColor: Y,
+  borderLeftColor: Y,
+  filter: Nr,
+  WebkitFilter: Nr
+}), he = function(t) {
+  return Hu[t];
+};
+function ye(t, r) {
+  var e, n = he(t);
+  return n !== Nr && (n = it), (e = n.getAnimatableNone) === null || e === void 0 ? void 0 : e.call(n, r);
+}
+function Uu(t) {
+  t.when, t.delay, t.delayChildren, t.staggerChildren, t.staggerDirection, t.repeat, t.repeatType, t.repeatDelay, t.from;
+  var r = J(t, ["when", "delay", "delayChildren", "staggerChildren", "staggerDirection", "repeat", "repeatType", "repeatDelay", "from"]);
+  return !!Object.keys(r).length;
+}
+var We = !1;
+function Nu(t) {
+  var r = t.ease, e = t.times, n = t.yoyo, a = t.flip, o = t.loop, i = J(t, ["ease", "times", "yoyo", "flip", "loop"]), u = h({}, i);
+  return e && (u.offset = e), i.duration && (u.duration = pr(i.duration)), i.repeatDelay && (u.repeatDelay = pr(i.repeatDelay)), r && (u.ease = Bu(r) ? r.map(Ye) : Ye(r)), i.type === "tween" && (u.type = "keyframes"), (n || o || a) && (br(!We, "yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options."), We = !0, n ? u.repeatType = "reverse" : o ? u.repeatType = "loop" : a && (u.repeatType = "mirror"), u.repeat = o || n || a || i.repeat), i.type !== "spring" && (u.type = "keyframes"), u;
+}
+function _u(t, r) {
+  var e, n = be(t, r) || {};
+  return (e = n.delay) !== null && e !== void 0 ? e : 0;
+}
+function Ku(t) {
+  return Array.isArray(t.to) && t.to[0] === null && (t.to = W([], H(t.to)), t.to[0] = t.from), t;
+}
+function zu(t, r, e) {
+  var n;
+  return Array.isArray(r.to) && ((n = t.duration) !== null && n !== void 0 || (t.duration = 0.8)), Ku(r), Uu(t) || (t = h(h({}, t), ju(e, r.to))), h(h({}, r), Nu(t));
+}
+function Yu(t, r, e, n, a) {
+  var o, i = be(n, t), u = (o = i.from) !== null && o !== void 0 ? o : r.get(), f = Ge(t, e);
+  u === "none" && f && typeof e == "string" ? u = ye(t, e) : Ze(u) && typeof e == "string" ? u = $e(e) : !Array.isArray(e) && Ze(e) && typeof u == "string" && (e = $e(u));
+  var s = Ge(t, u);
+  br(s === f, "You are trying to animate " + t + ' from "' + u + '" to "' + e + '". ' + u + " is not an animatable value - to enable this animation set " + u + " to a value animatable to " + e + " via the `style` property.");
+  function l() {
+    var v = {
+      from: u,
+      to: e,
+      velocity: r.getVelocity(),
+      onComplete: a,
+      onUpdate: function(d) {
+        return r.set(d);
+      }
+    };
+    return i.type === "inertia" || i.type === "decay" ? Vu(h(h({}, v), i)) : Va(h(h({}, zu(i, v, t)), { onUpdate: function(d) {
+      var c;
+      v.onUpdate(d), (c = i.onUpdate) === null || c === void 0 || c.call(i, d);
+    }, onComplete: function() {
+      var d;
+      v.onComplete(), (d = i.onComplete) === null || d === void 0 || d.call(i);
+    } }));
+  }
+  function m() {
+    var v;
+    return r.set(e), a(), (v = i == null ? void 0 : i.onComplete) === null || v === void 0 || v.call(i), { stop: function() {
+    } };
+  }
+  return !s || !f || i.type === !1 ? m : l;
+}
+function Ze(t) {
+  return t === 0 || typeof t == "string" && parseFloat(t) === 0 && t.indexOf(" ") === -1;
+}
+function $e(t) {
+  return typeof t == "number" ? 0 : ye("", t);
+}
+function be(t, r) {
+  return t[r] || t.default || t;
+}
+function gr(t, r, e, n) {
+  return n === void 0 && (n = {}), r.start(function(a) {
+    var o, i, u = Yu(t, r, e, n, a), f = _u(n, t), s = function() {
+      return i = u();
+    };
+    return f ? o = setTimeout(s, pr(f)) : s(), function() {
+      clearTimeout(o), i == null || i.stop();
+    };
+  });
+}
+var Gu = function(t) {
+  return /^\-?\d*\.?\d+$/.test(t);
+};
+function Oa(t, r) {
+  t.indexOf(r) === -1 && t.push(r);
+}
+function Ia(t, r) {
+  var e = t.indexOf(r);
+  e > -1 && t.splice(e, 1);
+}
+var ur = (
+  /** @class */
+  function() {
+    function t() {
+      this.subscriptions = [];
+    }
+    return t.prototype.add = function(r) {
+      var e = this;
+      return Oa(this.subscriptions, r), function() {
+        return Ia(e.subscriptions, r);
+      };
+    }, t.prototype.notify = function(r, e, n) {
+      var a = this.subscriptions.length;
+      if (a)
+        if (a === 1)
+          this.subscriptions[0](r, e, n);
+        else
+          for (var o = 0; o < a; o++) {
+            var i = this.subscriptions[o];
+            i && i(r, e, n);
+          }
+    }, t.prototype.getSize = function() {
+      return this.subscriptions.length;
+    }, t.prototype.clear = function() {
+      this.subscriptions.length = 0;
+    }, t;
+  }()
+), Xu = function(t) {
+  return !isNaN(parseFloat(t));
+}, Wu = (
+  /** @class */
+  function() {
+    function t(r) {
+      var e = this;
+      this.timeDelta = 0, this.lastUpdated = 0, this.updateSubscribers = new ur(), this.velocityUpdateSubscribers = new ur(), this.renderSubscribers = new ur(), this.canTrackVelocity = !1, this.updateAndNotify = function(n, a) {
+        a === void 0 && (a = !0), e.prev = e.current, e.current = n;
+        var o = dr(), i = o.delta, u = o.timestamp;
+        e.lastUpdated !== u && (e.timeDelta = i, e.lastUpdated = u, nt.postRender(e.scheduleVelocityCheck)), e.prev !== e.current && e.updateSubscribers.notify(e.current), e.velocityUpdateSubscribers.getSize() && e.velocityUpdateSubscribers.notify(e.getVelocity()), a && e.renderSubscribers.notify(e.current);
+      }, this.scheduleVelocityCheck = function() {
+        return nt.postRender(e.velocityCheck);
+      }, this.velocityCheck = function(n) {
+        var a = n.timestamp;
+        a !== e.lastUpdated && (e.prev = e.current, e.velocityUpdateSubscribers.notify(e.getVelocity()));
+      }, this.hasAnimated = !1, this.prev = this.current = r, this.canTrackVelocity = Xu(this.current);
+    }
+    return t.prototype.onChange = function(r) {
+      return this.updateSubscribers.add(r);
+    }, t.prototype.clearListeners = function() {
+      this.updateSubscribers.clear();
+    }, t.prototype.onRenderRequest = function(r) {
+      return r(this.get()), this.renderSubscribers.add(r);
+    }, t.prototype.attach = function(r) {
+      this.passiveEffect = r;
+    }, t.prototype.set = function(r, e) {
+      e === void 0 && (e = !0), !e || !this.passiveEffect ? this.updateAndNotify(r, e) : this.passiveEffect(r, 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(r) {
+      var e = this;
+      return this.stop(), new Promise(function(n) {
+        e.hasAnimated = !0, e.stopAnimation = r(n);
+      }).then(function() {
+        return e.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 mt(t) {
+  return new Wu(t);
+}
+var Ba = function(t) {
+  return function(r) {
+    return r.test(t);
+  };
+}, Zu = {
+  test: function(t) {
+    return t === "auto";
+  },
+  parse: function(t) {
+    return t;
+  }
+}, Fa = [gt, E, At, ut, Go, Yo, Zu], rr = function(t) {
+  return Fa.find(Ba(t));
+}, $u = W(W([], H(Fa)), [Y, it]), qu = function(t) {
+  return $u.find(Ba(t));
+};
+function Ju(t, r, e) {
+  t.hasValue(r) ? t.getValue(r).set(e) : t.addValue(r, mt(e));
+}
+function Qu(t, r) {
+  var e = Sr(t, r), n = e ? t.makeTargetAnimatable(e, !1) : {}, a = n.transitionEnd, o = a === void 0 ? {} : a;
+  n.transition;
+  var i = J(n, ["transitionEnd", "transition"]);
+  i = h(h({}, i), o);
+  for (var u in i) {
+    var f = mi(i[u]);
+    Ju(t, u, f);
+  }
+}
+function ku(t, r, e) {
+  var n, a, o, i, u = Object.keys(r).filter(function(d) {
+    return !t.hasValue(d);
+  }), f = u.length;
+  if (f)
+    for (var s = 0; s < f; s++) {
+      var l = u[s], m = r[l], v = null;
+      Array.isArray(m) && (v = m[0]), v === null && (v = (a = (n = e[l]) !== null && n !== void 0 ? n : t.readValue(l)) !== null && a !== void 0 ? a : r[l]), v != null && (typeof v == "string" && Gu(v) ? v = parseFloat(v) : !qu(v) && it.test(m) && (v = ye(l, m)), t.addValue(l, mt(v)), (o = (i = e)[l]) !== null && o !== void 0 || (i[l] = v), t.setBaseTarget(l, v));
+    }
+}
+function ts(t, r) {
+  if (r) {
+    var e = r[t] || r.default || r;
+    return e.from;
+  }
+}
+function rs(t, r, e) {
+  var n, a, o = {};
+  for (var i in t)
+    o[i] = (n = ts(i, r)) !== null && n !== void 0 ? n : (a = e.getValue(i)) === null || a === void 0 ? void 0 : a.get();
+  return o;
+}
+function es(t, r, e) {
+  e === void 0 && (e = {}), t.notifyAnimationStart();
+  var n;
+  if (Array.isArray(r)) {
+    var a = r.map(function(i) {
+      return Wr(t, i, e);
+    });
+    n = Promise.all(a);
+  } else if (typeof r == "string")
+    n = Wr(t, r, e);
+  else {
+    var o = typeof r == "function" ? Sr(t, r, e.custom) : r;
+    n = ja(t, o, e);
+  }
+  return n.then(function() {
+    return t.notifyAnimationComplete(r);
+  });
+}
+function Wr(t, r, e) {
+  var n;
+  e === void 0 && (e = {});
+  var a = Sr(t, r, e.custom), o = (a || {}).transition, i = o === void 0 ? t.getDefaultTransition() || {} : o;
+  e.transitionOverride && (i = e.transitionOverride);
+  var u = a ? function() {
+    return ja(t, a, e);
+  } : function() {
+    return Promise.resolve();
+  }, f = !((n = t.variantChildren) === null || n === void 0) && n.size ? function(d) {
+    d === void 0 && (d = 0);
+    var c = i.delayChildren, y = c === void 0 ? 0 : c, p = i.staggerChildren, g = i.staggerDirection;
+    return ns(t, r, y + d, p, g, e);
+  } : function() {
+    return Promise.resolve();
+  }, s = i.when;
+  if (s) {
+    var l = H(s === "beforeChildren" ? [u, f] : [f, u], 2), m = l[0], v = l[1];
+    return m().then(v);
+  } else
+    return Promise.all([u(), f(e.delay)]);
+}
+function ja(t, r, e) {
+  var n, a = e === void 0 ? {} : e, o = a.delay, i = o === void 0 ? 0 : o, u = a.transitionOverride, f = a.type, s = t.makeTargetAnimatable(r), l = s.transition, m = l === void 0 ? t.getDefaultTransition() : l, v = s.transitionEnd, d = J(s, ["transition", "transitionEnd"]);
+  u && (m = u);
+  var c = [], y = f && ((n = t.animationState) === null || n === void 0 ? void 0 : n.getState()[f]);
+  for (var p in d) {
+    var g = t.getValue(p), S = d[p];
+    if (!(!g || S === void 0 || y && os(y, p))) {
+      var M = gr(p, g, S, h({ delay: i }, m));
+      c.push(M);
+    }
+  }
+  return Promise.all(c).then(function() {
+    v && Qu(t, v);
+  });
+}
+function ns(t, r, e, n, a, o) {
+  e === void 0 && (e = 0), n === void 0 && (n = 0), a === void 0 && (a = 1);
+  var i = [], 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(as).forEach(function(s, l) {
+    i.push(Wr(s, r, h(h({}, o), { delay: e + f(l) })).then(function() {
+      return s.notifyAnimationComplete(r);
+    }));
+  }), Promise.all(i);
+}
+function as(t, r) {
+  return t.sortNodePosition(r);
+}
+function os(t, r) {
+  var e = t.protectedKeys, n = t.needsAnimating, a = e.hasOwnProperty(r) && n[r] !== !0;
+  return n[r] = !1, a;
+}
+var Pe = [
+  F.Animate,
+  F.Hover,
+  F.Tap,
+  F.Drag,
+  F.Focus,
+  F.Exit
+], is = W([], H(Pe)).reverse(), us = Pe.length;
+function ss(t) {
+  return function(r) {
+    return Promise.all(r.map(function(e) {
+      var n = e.animation, a = e.options;
+      return es(t, n, a);
+    }));
+  };
+}
+function fs(t) {
+  var r = ss(t), e = cs(), n = {}, a = !0, o = function(l, m) {
+    var v = Sr(t, m);
+    if (v) {
+      v.transition;
+      var d = v.transitionEnd, c = J(v, ["transition", "transitionEnd"]);
+      l = h(h(h({}, l), c), d);
+    }
+    return l;
+  };
+  function i(l) {
+    return n[l] !== void 0;
+  }
+  function u(l) {
+    r = l(t);
+  }
+  function f(l, m) {
+    for (var v, d = t.getProps(), c = t.getVariantContext(!0) || {}, y = [], p = /* @__PURE__ */ new Set(), g = {}, S = 1 / 0, M = function(w) {
+      var C = is[w], A = e[C], D = (v = d[C]) !== null && v !== void 0 ? v : c[C], R = rt(D), j = C === m ? A.isActive : null;
+      j === !1 && (S = w);
+      var U = D === c[C] && D !== d[C] && R;
+      if (U && a && t.manuallyAnimateOnMount && (U = !1), A.protectedKeys = h({}, g), // If it isn't active and hasn't *just* been set as inactive
+      !A.isActive && j === null || // If we didn't and don't have any defined prop for this animation type
+      !D && !A.prevProp || // Or if the prop doesn't define an animation
+      le(D) || typeof D == "boolean")
+        return "continue";
+      var B = ls(A.prevProp, D) || // If we're making this variant active, we want to always make it active
+      C === m && A.isActive && !U && R || // If we removed a higher-priority variant (i is in reverse order)
+      w > S && R, Q = Array.isArray(D) ? D : [D], O = Q.reduce(o, {});
+      j === !1 && (O = {});
+      var $ = A.prevResolvedValues, q = $ === void 0 ? {} : $, ht = h(h({}, q), O), tt = function(ct) {
+        B = !0, p.delete(ct), A.needsAnimating[ct] = !0;
+      };
+      for (var _ in ht) {
+        var et = O[_], lt = q[_];
+        g.hasOwnProperty(_) || (et !== lt ? jt(et) && jt(lt) ? Ra(et, lt) ? A.protectedKeys[_] = !0 : tt(_) : et !== void 0 ? tt(_) : p.add(_) : et !== void 0 && p.has(_) ? tt(_) : A.protectedKeys[_] = !0);
+      }
+      A.prevProp = D, A.prevResolvedValues = O, A.isActive && (g = h(h({}, g), O)), a && t.blockInitialAnimation && (B = !1), B && !U && y.push.apply(y, W([], H(Q.map(function(ct) {
+        return {
+          animation: ct,
+          options: h({ type: C }, l)
+        };
+      }))));
+    }, L = 0; L < us; L++)
+      M(L);
+    if (n = h({}, g), p.size) {
+      var x = {};
+      p.forEach(function(w) {
+        var C = t.getBaseTarget(w);
+        C !== void 0 && (x[w] = C);
+      }), y.push({ animation: x });
+    }
+    var T = !!y.length;
+    return a && d.initial === !1 && !t.manuallyAnimateOnMount && (T = !1), a = !1, T ? r(y) : Promise.resolve();
+  }
+  function s(l, m, v) {
+    var d;
+    return e[l].isActive === m ? Promise.resolve() : ((d = t.variantChildren) === null || d === void 0 || d.forEach(function(c) {
+      var y;
+      return (y = c.animationState) === null || y === void 0 ? void 0 : y.setActive(l, m);
+    }), e[l].isActive = m, f(v, l));
+  }
+  return {
+    isAnimated: i,
+    animateChanges: f,
+    setActive: s,
+    setAnimateFunction: u,
+    getState: function() {
+      return e;
+    }
+  };
+}
+function ls(t, r) {
+  return typeof r == "string" ? r !== t : Rn(r) ? !Ra(r, t) : !1;
+}
+function yt(t) {
+  return t === void 0 && (t = !1), {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function cs() {
+  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 vs = {
+  animation: dt(function(t) {
+    var r = t.visualElement, e = t.animate;
+    r.animationState || (r.animationState = fs(r)), le(e) && at(function() {
+      return e.subscribe(r);
+    }, [e]);
+  }),
+  exit: dt(function(t) {
+    var r = t.custom, e = t.visualElement, n = H(Dn(), 2), a = n[0], o = n[1], i = z(Tr);
+    at(function() {
+      var u, f, s = (u = e.animationState) === null || u === void 0 ? void 0 : u.setActive(F.Exit, !a, { custom: (f = i == null ? void 0 : i.custom) !== null && f !== void 0 ? f : r });
+      !a && (s == null || s.then(o));
+    }, [a]);
+  })
+}, Ha = (
+  /** @class */
+  function() {
+    function t(r, e, n) {
+      var a = this, o = n === void 0 ? {} : n, i = o.transformPagePoint;
+      if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.updatePoint = function() {
+        if (a.lastMoveEvent && a.lastMoveEventInfo) {
+          var v = Fr(a.lastMoveEventInfo, a.history), d = a.startEvent !== null, c = La(v.offset, { x: 0, y: 0 }) >= 3;
+          if (!(!d && !c)) {
+            var y = v.point, p = dr().timestamp;
+            a.history.push(h(h({}, y), { timestamp: p }));
+            var g = a.handlers, S = g.onStart, M = g.onMove;
+            d || (S && S(a.lastMoveEvent, v), a.startEvent = a.lastMoveEvent), M && M(a.lastMoveEvent, v);
+          }
+        }
+      }, this.handlePointerMove = function(v, d) {
+        if (a.lastMoveEvent = v, a.lastMoveEventInfo = Br(d, a.transformPagePoint), ra(v) && v.buttons === 0) {
+          a.handlePointerUp(v, d);
+          return;
+        }
+        nt.update(a.updatePoint, !0);
+      }, this.handlePointerUp = function(v, d) {
+        a.end();
+        var c = a.handlers, y = c.onEnd, p = c.onSessionEnd, g = Fr(Br(d, a.transformPagePoint), a.history);
+        a.startEvent && y && y(v, g), p && p(v, g);
+      }, !(ea(r) && r.touches.length > 1)) {
+        this.handlers = e, this.transformPagePoint = i;
+        var u = ve(r), f = Br(u, this.transformPagePoint), s = f.point, l = dr().timestamp;
+        this.history = [h(h({}, s), { timestamp: l })];
+        var m = e.onSessionStart;
+        m && m(r, Fr(f, this.history)), this.removeListeners = Xt(Vt(window, "pointermove", this.handlePointerMove), Vt(window, "pointerup", this.handlePointerUp), Vt(window, "pointercancel", this.handlePointerUp));
+      }
+    }
+    return t.prototype.updateHandlers = function(r) {
+      this.handlers = r;
+    }, t.prototype.end = function() {
+      this.removeListeners && this.removeListeners(), Rt.update(this.updatePoint);
+    }, t;
+  }()
+);
+function Br(t, r) {
+  return r ? { point: r(t.point) } : t;
+}
+function qe(t, r) {
+  return { x: t.x - r.x, y: t.y - r.y };
+}
+function Fr(t, r) {
+  var e = t.point;
+  return {
+    point: e,
+    delta: qe(e, Ua(r)),
+    offset: qe(e, ds(r)),
+    velocity: ms(r, 0.1)
+  };
+}
+function ds(t) {
+  return t[0];
+}
+function Ua(t) {
+  return t[t.length - 1];
+}
+function ms(t, r) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  for (var e = t.length - 1, n = null, a = Ua(t); e >= 0 && (n = t[e], !(a.timestamp - n.timestamp > pr(r))); )
+    e--;
+  if (!n)
+    return { x: 0, y: 0 };
+  var o = (a.timestamp - n.timestamp) / 1e3;
+  if (o === 0)
+    return { x: 0, y: 0 };
+  var i = {
+    x: (a.x - n.x) / o,
+    y: (a.y - n.y) / o
+  };
+  return i.x === 1 / 0 && (i.x = 0), i.y === 1 / 0 && (i.y = 0), i;
+}
+function ps(t) {
+  return t;
+}
+function Na(t) {
+  var r = t.top, e = t.left, n = t.right, a = t.bottom;
+  return {
+    x: { min: e, max: n },
+    y: { min: r, max: a }
+  };
+}
+function gs(t) {
+  var r = t.x, e = t.y;
+  return {
+    top: e.min,
+    bottom: e.max,
+    left: r.min,
+    right: r.max
+  };
+}
+function hs(t, r) {
+  var e = t.top, n = t.left, a = t.bottom, o = t.right;
+  r === void 0 && (r = ps);
+  var i = r({ x: n, y: e }), u = r({ x: o, y: a });
+  return {
+    top: i.y,
+    left: i.x,
+    bottom: u.y,
+    right: u.x
+  };
+}
+function ft() {
+  return { x: { min: 0, max: 1 }, y: { min: 0, max: 1 } };
+}
+function ys(t) {
+  return {
+    x: h({}, t.x),
+    y: h({}, t.y)
+  };
+}
+var Je = {
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+};
+function Qe() {
+  return {
+    x: h({}, Je),
+    y: h({}, Je)
+  };
+}
+function G(t) {
+  return [t("x"), t("y")];
+}
+function _a(t, r, e) {
+  var n = r.min, a = r.max;
+  return n !== void 0 && t < n ? t = e ? Z(n, t, e.min) : Math.max(t, n) : a !== void 0 && t > a && (t = e ? Z(a, t, e.max) : Math.min(t, a)), t;
+}
+function bs(t, r, e, n, a) {
+  var o = t - r * e;
+  return n ? _a(o, n, a) : o;
+}
+function ke(t, r, e) {
+  return {
+    min: r !== void 0 ? t.min + r : void 0,
+    max: e !== void 0 ? t.max + e - (t.max - t.min) : void 0
+  };
+}
+function Ps(t, r) {
+  var e = r.top, n = r.left, a = r.bottom, o = r.right;
+  return {
+    x: ke(t.x, n, o),
+    y: ke(t.y, e, a)
+  };
+}
+function tn(t, r) {
+  var e, n = r.min - t.min, a = r.max - t.max;
+  return r.max - r.min < t.max - t.min && (e = H([a, n], 2), n = e[0], a = e[1]), {
+    min: t.min + n,
+    max: t.min + a
+  };
+}
+function xs(t, r) {
+  return {
+    x: tn(t.x, r.x),
+    y: tn(t.y, r.y)
+  };
+}
+function Ts(t, r, e) {
+  var n = t.max - t.min, a = Z(r.min, r.max - n, e);
+  return { min: a, max: a + n };
+}
+function Ss(t, r) {
+  var e = {};
+  return r.min !== void 0 && (e.min = r.min - t.min), r.max !== void 0 && (e.max = r.max - t.min), e;
+}
+var Ka = 0.35;
+function As(t) {
+  return t === !1 ? t = 0 : t === !0 && (t = Ka), {
+    x: rn(t, "left", "right"),
+    y: rn(t, "top", "bottom")
+  };
+}
+function rn(t, r, e) {
+  return {
+    min: en(t, r),
+    max: en(t, e)
+  };
+}
+function en(t, r) {
+  var e;
+  return typeof t == "number" ? t : (e = t[r]) !== null && e !== void 0 ? e : 0;
+}
+function za(t, r) {
+  var e = t.getBoundingClientRect();
+  return Na(hs(e, r));
+}
+var Vs = function(t) {
+  return cr(0, 1, t);
+};
+function nn(t, r, e) {
+  return r === void 0 && (r = 0), e === void 0 && (e = 0.01), La(t, r) < e;
+}
+function Nt(t) {
+  return t.max - t.min;
+}
+function Cs(t, r) {
+  var e = 0.5, n = Nt(t), a = Nt(r);
+  return a > n ? e = Ht(r.min, r.max - n, t.min) : n > a && (e = Ht(t.min, t.max - a, r.min)), Vs(e);
+}
+function an(t, r, e, n) {
+  n === void 0 && (n = 0.5), t.origin = n, t.originPoint = Z(r.min, r.max, t.origin), t.scale = Nt(e) / Nt(r), nn(t.scale, 1, 1e-4) && (t.scale = 1), t.translate = Z(e.min, e.max, t.origin) - t.originPoint, nn(t.translate) && (t.translate = 0);
+}
+function Ya(t, r, e, n) {
+  an(t.x, r.x, e.x, on(n.originX)), an(t.y, r.y, e.y, on(n.originY));
+}
+function on(t) {
+  return typeof t == "number" ? t : 0.5;
+}
+function un(t, r, e) {
+  t.min = e.min + r.min, t.max = t.min + Nt(r);
+}
+function Ls(t, r) {
+  un(t.target.x, t.relativeTarget.x, r.target.x), un(t.target.y, t.relativeTarget.y, r.target.y);
+}
+var xe = function(t, r) {
+  return t.depth - r.depth;
+};
+function Ga(t) {
+  var r = t.projection.isEnabled;
+  return r || t.shouldResetTransform();
+}
+function hr(t, r) {
+  r === void 0 && (r = []);
+  var e = t.parent;
+  return e && hr(e, r), Ga(t) && r.push(t), r;
+}
+function ws(t) {
+  var r = [], e = function(n) {
+    Ga(n) && r.push(n), n.children.forEach(e);
+  };
+  return t.children.forEach(e), r.sort(xe);
+}
+function sr(t) {
+  if (!t.shouldResetTransform()) {
+    var r = t.getLayoutState();
+    t.notifyBeforeLayoutMeasure(r.layout), r.isHydrated = !0, r.layout = t.measureViewportBox(), r.layoutCorrected = ys(r.layout), t.notifyLayoutMeasure(r.layout, t.prevViewportBox || r.layout), nt.update(function() {
+      return t.rebaseProjectionTarget();
+    });
+  }
+}
+function Es(t) {
+  t.shouldResetTransform() || (t.prevViewportBox = t.measureViewportBox(!1), t.rebaseProjectionTarget(!1, t.prevViewportBox));
+}
+function Ms(t, r, e, n) {
+  t.min = Z(r.min, e.min, n), t.max = Z(r.max, e.max, n);
+}
+function sn(t, r) {
+  return {
+    min: r.min - t.min,
+    max: r.max - t.min
+  };
+}
+function Lt(t, r) {
+  return {
+    x: sn(t.x, r.x),
+    y: sn(t.y, r.y)
+  };
+}
+function Ds(t, r) {
+  var e = t.getLayoutId(), n = r.getLayoutId();
+  return e !== n || n === void 0 && t !== r;
+}
+function Xa(t) {
+  var r = t.getProps(), e = r.drag, n = r._dragX;
+  return e && !n;
+}
+function fn(t, r) {
+  t.min = r.min, t.max = r.max;
+}
+function Rs(t, r) {
+  fn(t.x, r.x), fn(t.y, r.y);
+}
+function yr(t, r, e) {
+  var n = t - e, a = r * n;
+  return e + a;
+}
+function ln(t, r, e, n, a) {
+  return a !== void 0 && (t = yr(t, a, n)), yr(t, e, n) + r;
+}
+function Zr(t, r, e, n, a) {
+  r === void 0 && (r = 0), e === void 0 && (e = 1), t.min = ln(t.min, r, e, n, a), t.max = ln(t.max, r, e, n, a);
+}
+function Os(t, r) {
+  var e = r.x, n = r.y;
+  Zr(t.x, e.translate, e.scale, e.originPoint), Zr(t.y, n.translate, n.scale, n.originPoint);
+}
+function cn(t, r, e, n) {
+  var a = H(n, 3), o = a[0], i = a[1], u = a[2];
+  t.min = r.min, t.max = r.max;
+  var f = e[u] !== void 0 ? e[u] : 0.5, s = Z(r.min, r.max, f);
+  Zr(t, e[o], e[i], s, e.scale);
+}
+var Wa = ["x", "scaleX", "originX"], Za = ["y", "scaleY", "originY"];
+function $r(t, r, e) {
+  cn(t.x, r.x, e, Wa), cn(t.y, r.y, e, Za);
+}
+function vn(t, r, e, n, a) {
+  return t -= r, t = yr(t, 1 / e, n), a !== void 0 && (t = yr(t, 1 / a, n)), t;
+}
+function Is(t, r, e, n, a) {
+  r === void 0 && (r = 0), e === void 0 && (e = 1), n === void 0 && (n = 0.5);
+  var o = Z(t.min, t.max, n) - r;
+  t.min = vn(t.min, r, e, o, a), t.max = vn(t.max, r, e, o, a);
+}
+function dn(t, r, e) {
+  var n = H(e, 3), a = n[0], o = n[1], i = n[2];
+  Is(t, r[a], r[o], r[i], r.scale);
+}
+function $a(t, r) {
+  dn(t.x, r, Wa), dn(t.y, r, Za);
+}
+function Bs(t, r, e) {
+  var n = e.length;
+  if (n) {
+    r.x = r.y = 1;
+    for (var a, o, i = 0; i < n; i++)
+      a = e[i], o = a.getLayoutState().delta, r.x *= o.x.scale, r.y *= o.y.scale, Os(t, o), Xa(a) && $r(t, t, a.getLatestValues());
+  }
+}
+function Fs(t, r) {
+  r === void 0 && (r = !0);
+  var e = t.getProjectionParent();
+  if (!e)
+    return !1;
+  var n;
+  return r ? (n = Lt(e.projection.target, t.projection.target), $a(n, e.getLatestValues())) : n = Lt(e.getLayoutState().layout, t.getLayoutState().layout), G(function(a) {
+    return t.setProjectionTargetAxis(a, n[a].min, n[a].max, !0);
+  }), !0;
+}
+var Ot = /* @__PURE__ */ new Set();
+function mn(t, r, e) {
+  t[e] || (t[e] = []), t[e].push(r);
+}
+function qr(t) {
+  return Ot.add(t), function() {
+    return Ot.delete(t);
+  };
+}
+function Jr() {
+  if (Ot.size) {
+    var t = 0, r = [[]], e = [], n = function(u) {
+      return mn(r, u, t);
+    }, a = function(u) {
+      mn(e, u, t), t++;
+    };
+    Ot.forEach(function(u) {
+      u(n, a), t = 0;
+    }), Ot.clear();
+    for (var o = e.length, i = 0; i <= o; i++)
+      r[i] && r[i].forEach(pn), e[i] && e[i].forEach(pn);
+  }
+}
+var pn = function(t) {
+  return t();
+}, js = /* @__PURE__ */ new WeakMap(), gn, Hs = (
+  /** @class */
+  function() {
+    function t(r) {
+      var e = r.visualElement;
+      this.isDragging = !1, this.currentDirection = null, this.constraints = !1, this.elastic = ft(), this.props = {}, this.hasMutatedConstraints = !1, this.cursorProgress = {
+        x: 0.5,
+        y: 0.5
+      }, this.originPoint = {}, this.openGlobalLock = null, this.panSession = null, this.visualElement = e, this.visualElement.enableLayoutProjection(), js.set(e, this);
+    }
+    return t.prototype.start = function(r, e) {
+      var n = this, a = e === void 0 ? {} : e, o = a.snapToCursor, i = o === void 0 ? !1 : o, u = a.cursorProgress, f = function(d) {
+        var c;
+        n.stopMotion();
+        var y = Ci(d).point;
+        (c = n.cancelLayout) === null || c === void 0 || c.call(n), n.cancelLayout = qr(function(p, g) {
+          var S = hr(n.visualElement), M = ws(n.visualElement), L = W(W([], H(S)), H(M)), x = !1;
+          n.isLayoutDrag() && n.visualElement.lockProjectionTarget(), g(function() {
+            L.forEach(function(T) {
+              return T.resetTransform();
+            });
+          }), p(function() {
+            sr(n.visualElement), M.forEach(sr);
+          }), g(function() {
+            L.forEach(function(T) {
+              return T.restoreTransform();
+            }), i && (x = n.snapToCursor(y));
+          }), p(function() {
+            var T = !!(n.getAxisMotionValue("x") && !n.isExternalDrag());
+            T || n.visualElement.rebaseProjectionTarget(!0, n.visualElement.measureViewportBox(!1)), n.visualElement.scheduleUpdateLayoutProjection();
+            var w = n.visualElement.projection;
+            G(function(C) {
+              if (!x) {
+                var A = w.target[C], D = A.min, R = A.max;
+                n.cursorProgress[C] = u ? u[C] : Ht(D, R, y[C]);
+              }
+              var j = n.getAxisMotionValue(C);
+              j && (n.originPoint[C] = j.get());
+            });
+          }), g(function() {
+            Tt.update(), Tt.preRender(), Tt.render(), Tt.postRender();
+          }), p(function() {
+            return n.resolveDragConstraints();
+          });
+        });
+      }, s = function(d, c) {
+        var y, p, g, S = n.props, M = S.drag, L = S.dragPropagation;
+        M && !L && (n.openGlobalLock && n.openGlobalLock(), n.openGlobalLock = ia(M), !n.openGlobalLock) || (Jr(), n.isDragging = !0, n.currentDirection = null, (p = (y = n.props).onDragStart) === null || p === void 0 || p.call(y, d, c), (g = n.visualElement.animationState) === null || g === void 0 || g.setActive(F.Drag, !0));
+      }, l = function(d, c) {
+        var y, p, g, S, M = n.props, L = M.dragPropagation, x = M.dragDirectionLock;
+        if (!(!L && !n.openGlobalLock)) {
+          var T = c.offset;
+          if (x && n.currentDirection === null) {
+            n.currentDirection = Us(T), n.currentDirection !== null && ((p = (y = n.props).onDirectionLock) === null || p === void 0 || p.call(y, n.currentDirection));
+            return;
+          }
+          n.updateAxis("x", c.point, T), n.updateAxis("y", c.point, T), (S = (g = n.props).onDrag) === null || S === void 0 || S.call(g, d, c), gn = d;
+        }
+      }, m = function(d, c) {
+        return n.stop(d, c);
+      }, v = this.props.transformPagePoint;
+      this.panSession = new Ha(r, {
+        onSessionStart: f,
+        onStart: s,
+        onMove: l,
+        onSessionEnd: m
+      }, { transformPagePoint: v });
+    }, t.prototype.resolveDragConstraints = function() {
+      var r = this, e = this.props, n = e.dragConstraints, a = e.dragElastic, o = this.visualElement.getLayoutState().layoutCorrected;
+      n ? this.constraints = jr(n) ? this.resolveRefConstraints(o, n) : Ps(o, n) : this.constraints = !1, this.elastic = As(a), this.constraints && !this.hasMutatedConstraints && G(function(i) {
+        r.getAxisMotionValue(i) && (r.constraints[i] = Ss(o[i], r.constraints[i]));
+      });
+    }, t.prototype.resolveRefConstraints = function(r, e) {
+      var n = this.props, a = n.onMeasureDragConstraints, o = n.transformPagePoint, i = e.current;
+      X(i !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop."), this.constraintsBox = za(i, o);
+      var u = xs(r, this.constraintsBox);
+      if (a) {
+        var f = a(gs(u));
+        this.hasMutatedConstraints = !!f, f && (u = Na(f));
+      }
+      return u;
+    }, t.prototype.cancelDrag = function() {
+      var r, e;
+      this.visualElement.unlockProjectionTarget(), (r = this.cancelLayout) === null || r === void 0 || r.call(this), this.isDragging = !1, this.panSession && this.panSession.end(), this.panSession = null, !this.props.dragPropagation && this.openGlobalLock && (this.openGlobalLock(), this.openGlobalLock = null), (e = this.visualElement.animationState) === null || e === void 0 || e.setActive(F.Drag, !1);
+    }, t.prototype.stop = function(r, e) {
+      var n, a, o;
+      (n = this.panSession) === null || n === void 0 || n.end(), this.panSession = null;
+      var i = this.isDragging;
+      if (this.cancelDrag(), !!i) {
+        var u = e.velocity;
+        this.animateDragEnd(u), (o = (a = this.props).onDragEnd) === null || o === void 0 || o.call(a, r, e);
+      }
+    }, t.prototype.snapToCursor = function(r) {
+      var e = this;
+      return G(function(n) {
+        var a = e.props.drag;
+        if (er(n, a, e.currentDirection)) {
+          var o = e.getAxisMotionValue(n);
+          if (o) {
+            var i = e.visualElement.getLayoutState().layout, u = i[n].max - i[n].min, f = i[n].min + u / 2, s = r[n] - f;
+            e.originPoint[n] = r[n], o.set(s);
+          } else
+            return e.cursorProgress[n] = 0.5, !0;
+        }
+      }).includes(!0);
+    }, t.prototype.updateAxis = function(r, e, n) {
+      var a = this.props.drag;
+      if (er(r, a, this.currentDirection))
+        return this.getAxisMotionValue(r) ? this.updateAxisMotionValue(r, n) : this.updateVisualElementAxis(r, e);
+    }, t.prototype.updateAxisMotionValue = function(r, e) {
+      var n = this.getAxisMotionValue(r);
+      if (!(!e || !n)) {
+        var a = this.originPoint[r] + e[r], o = this.constraints ? _a(a, this.constraints[r], this.elastic[r]) : a;
+        n.set(o);
+      }
+    }, t.prototype.updateVisualElementAxis = function(r, e) {
+      var n, a = this.visualElement.getLayoutState().layout[r], o = a.max - a.min, i = this.cursorProgress[r], u = bs(e[r], o, i, (n = this.constraints) === null || n === void 0 ? void 0 : n[r], this.elastic[r]);
+      this.visualElement.setProjectionTargetAxis(r, u, u + o);
+    }, t.prototype.setProps = function(r) {
+      var e = r.drag, n = e === void 0 ? !1 : e, a = r.dragDirectionLock, o = a === void 0 ? !1 : a, i = r.dragPropagation, u = i === void 0 ? !1 : i, f = r.dragConstraints, s = f === void 0 ? !1 : f, l = r.dragElastic, m = l === void 0 ? Ka : l, v = r.dragMomentum, d = v === void 0 ? !0 : v, c = J(r, ["drag", "dragDirectionLock", "dragPropagation", "dragConstraints", "dragElastic", "dragMomentum"]);
+      this.props = h({
+        drag: n,
+        dragDirectionLock: o,
+        dragPropagation: u,
+        dragConstraints: s,
+        dragElastic: m,
+        dragMomentum: d
+      }, c);
+    }, t.prototype.getAxisMotionValue = function(r) {
+      var e = this.props, n = e.layout, a = e.layoutId, o = "_drag" + r.toUpperCase();
+      if (this.props[o])
+        return this.props[o];
+      if (!n && a === void 0)
+        return this.visualElement.getValue(r, 0);
+    }, t.prototype.isLayoutDrag = function() {
+      return !this.getAxisMotionValue("x");
+    }, t.prototype.isExternalDrag = function() {
+      var r = this.props, e = r._dragX, n = r._dragY;
+      return e || n;
+    }, t.prototype.animateDragEnd = function(r) {
+      var e = this, n = this.props, a = n.drag, o = n.dragMomentum, i = n.dragElastic, u = n.dragTransition, f = Fs(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 m = Lt(l.projection.targetFinal, s);
+          G(function(d) {
+            var c = m[d], y = c.min, p = c.max;
+            s[d] = {
+              min: isNaN(y) ? void 0 : y,
+              max: isNaN(p) ? void 0 : p
+            };
+          });
+        }
+      }
+      var v = G(function(d) {
+        var c;
+        if (er(d, a, e.currentDirection)) {
+          var y = (c = s == null ? void 0 : s[d]) !== null && c !== void 0 ? c : {}, p = i ? 200 : 1e6, g = i ? 40 : 1e7, S = h(h({
+            type: "inertia",
+            velocity: o ? r[d] : 0,
+            bounceStiffness: p,
+            bounceDamping: g,
+            timeConstant: 750,
+            restDelta: 1,
+            restSpeed: 10
+          }, u), y);
+          return e.getAxisMotionValue(d) ? e.startAxisValueAnimation(d, S) : e.visualElement.startLayoutAnimation(d, S, f);
+        }
+      });
+      return Promise.all(v).then(function() {
+        var d, c;
+        (c = (d = e.props).onDragTransitionEnd) === null || c === void 0 || c.call(d);
+      });
+    }, t.prototype.stopMotion = function() {
+      var r = this;
+      G(function(e) {
+        var n = r.getAxisMotionValue(e);
+        n ? n.stop() : r.visualElement.stopLayoutAnimation();
+      });
+    }, t.prototype.startAxisValueAnimation = function(r, e) {
+      var n = this.getAxisMotionValue(r);
+      if (n) {
+        var a = n.get();
+        return n.set(a), n.set(a), gr(r, n, 0, e);
+      }
+    }, t.prototype.scalePoint = function() {
+      var r = this, e = this.props, n = e.drag, a = e.dragConstraints;
+      if (!(!jr(a) || !this.constraintsBox)) {
+        this.stopMotion();
+        var o = { x: 0, y: 0 };
+        G(function(i) {
+          o[i] = Cs(r.visualElement.projection.target[i], r.constraintsBox[i]);
+        }), this.updateConstraints(function() {
+          G(function(i) {
+            if (er(i, n, null)) {
+              var u = Ts(r.visualElement.projection.target[i], r.constraintsBox[i], o[i]), f = u.min, s = u.max;
+              r.visualElement.setProjectionTargetAxis(i, f, s);
+            }
+          });
+        }), setTimeout(Jr, 1);
+      }
+    }, t.prototype.updateConstraints = function(r) {
+      var e = this;
+      this.cancelLayout = qr(function(n, a) {
+        var o = hr(e.visualElement);
+        a(function() {
+          return o.forEach(function(i) {
+            return i.resetTransform();
+          });
+        }), n(function() {
+          return sr(e.visualElement);
+        }), a(function() {
+          return o.forEach(function(i) {
+            return i.restoreTransform();
+          });
+        }), n(function() {
+          e.resolveDragConstraints();
+        }), r && a(r);
+      });
+    }, t.prototype.mount = function(r) {
+      var e = this, n = r.getInstance(), a = Vt(n, "pointerdown", function(f) {
+        var s = e.props, l = s.drag, m = s.dragListener, v = m === void 0 ? !0 : m;
+        l && v && e.start(f);
+      }), o = ce(window, "resize", function() {
+        e.scalePoint();
+      }), i = r.onLayoutUpdate(function() {
+        e.isDragging && e.resolveDragConstraints();
+      }), u = r.prevDragCursor;
+      return u && this.start(gn, { cursorProgress: u }), function() {
+        a == null || a(), o == null || o(), i == null || i(), e.cancelDrag();
+      };
+    }, t;
+  }()
+);
+function er(t, r, e) {
+  return (r === !0 || r === t) && (e === null || e === t);
+}
+function Us(t, r) {
+  r === void 0 && (r = 10);
+  var e = null;
+  return Math.abs(t.y) > r ? e = "y" : Math.abs(t.x) > r && (e = "x"), e;
+}
+function Ns(t) {
+  var r = t.dragControls, e = t.visualElement, n = z(Pr).transformPagePoint, a = ne(function() {
+    return new Hs({
+      visualElement: e
+    });
+  });
+  a.setProps(h(h({}, t), { transformPagePoint: n })), at(function() {
+    return r && r.subscribe(a);
+  }, [a]), at(function() {
+    return a.mount(e);
+  }, []);
+}
+function _s(t) {
+  var r = t.onPan, e = t.onPanStart, n = t.onPanEnd, a = t.onPanSessionStart, o = t.visualElement, i = r || e || n || a, u = It(null), f = z(Pr).transformPagePoint, s = {
+    onSessionStart: a,
+    onStart: e,
+    onMove: r,
+    onEnd: function(m, v) {
+      u.current = null, n && n(m, v);
+    }
+  };
+  at(function() {
+    u.current !== null && u.current.updateHandlers(s);
+  });
+  function l(m) {
+    u.current = new Ha(m, s, {
+      transformPagePoint: f
+    });
+  }
+  lr(o, "pointerdown", i && l), fa(function() {
+    return u.current && u.current.end();
+  });
+}
+var Ks = {
+  pan: dt(_s),
+  drag: dt(Ns)
+}, _t;
+(function(t) {
+  t[t.Entering = 0] = "Entering", t[t.Present = 1] = "Present", t[t.Exiting = 2] = "Exiting";
+})(_t || (_t = {}));
+var Qr;
+(function(t) {
+  t[t.Hide = 0] = "Hide", t[t.Show = 1] = "Show";
+})(Qr || (Qr = {}));
+function kr(t) {
+  return typeof t == "string" && t.startsWith("var(--");
+}
+var qa = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;
+function zs(t) {
+  var r = qa.exec(t);
+  if (!r)
+    return [,];
+  var e = H(r, 3), n = e[1], a = e[2];
+  return [n, a];
+}
+var Ys = 4;
+function te(t, r, e) {
+  e === void 0 && (e = 1), X(e <= Ys, 'Max CSS variable fallback depth detected in property "' + t + '". This may indicate a circular fallback dependency.');
+  var n = H(zs(t), 2), a = n[0], o = n[1];
+  if (a) {
+    var i = window.getComputedStyle(r).getPropertyValue(a);
+    return i ? i.trim() : kr(o) ? te(o, r, e + 1) : o;
+  }
+}
+function Gs(t, r, e) {
+  var n, a = J(r, []), o = t.getInstance();
+  if (!(o instanceof HTMLElement))
+    return { target: a, transitionEnd: e };
+  e && (e = h({}, e)), t.forEachValue(function(s) {
+    var l = s.get();
+    if (kr(l)) {
+      var m = te(l, o);
+      m && s.set(m);
+    }
+  });
+  for (var i in a) {
+    var u = a[i];
+    if (kr(u)) {
+      var f = te(u, o);
+      f && (a[i] = f, e && ((n = e[i]) !== null && n !== void 0 || (e[i] = u)));
+    }
+  }
+  return { target: a, transitionEnd: e };
+}
+function hn(t, r) {
+  return t / (r.max - r.min) * 100;
+}
+function Xs(t, r, e) {
+  var n = e.target;
+  if (typeof t == "string")
+    if (E.test(t))
+      t = parseFloat(t);
+    else
+      return t;
+  var a = hn(t, n.x), o = hn(t, n.y);
+  return a + "% " + o + "%";
+}
+var yn = "_$css";
+function Ws(t, r) {
+  var e = r.delta, n = r.treeScale, a = t, o = t.includes("var("), i = [];
+  o && (t = t.replace(qa, function(y) {
+    return i.push(y), yn;
+  }));
+  var u = it.parse(t);
+  if (u.length > 5)
+    return a;
+  var f = it.createTransformer(t), s = typeof u[0] != "number" ? 1 : 0, l = e.x.scale * n.x, m = e.y.scale * n.y;
+  u[0 + s] /= l, u[1 + s] /= m;
+  var v = Z(l, m, 0.5);
+  typeof u[2 + s] == "number" && (u[2 + s] /= v), typeof u[3 + s] == "number" && (u[3 + s] /= v);
+  var d = f(u);
+  if (o) {
+    var c = 0;
+    d = d.replace(yn, function() {
+      var y = i[c];
+      return c++, y;
+    });
+  }
+  return d;
+}
+var wt = {
+  process: Xs
+}, Zs = {
+  borderRadius: h(h({}, wt), { applyTo: [
+    "borderTopLeftRadius",
+    "borderTopRightRadius",
+    "borderBottomLeftRadius",
+    "borderBottomRightRadius"
+  ] }),
+  borderTopLeftRadius: wt,
+  borderTopRightRadius: wt,
+  borderBottomLeftRadius: wt,
+  borderBottomRightRadius: wt,
+  boxShadow: {
+    process: Ws
+  }
+}, bn = 1e3, $s = (
+  /** @class */
+  function(t) {
+    Ln(r, t);
+    function r() {
+      var e = t !== null && t.apply(this, arguments) || this;
+      return e.frameTarget = ft(), e.currentAnimationTarget = ft(), e.isAnimating = {
+        x: !1,
+        y: !1
+      }, e.stopAxisAnimation = {
+        x: void 0,
+        y: void 0
+      }, e.isAnimatingTree = !1, e.animate = function(n, a, o) {
+        o === void 0 && (o = {});
+        var i = o.originBox, u = o.targetBox, f = o.visibilityAction, s = o.shouldStackAnimate, l = o.onComplete, m = o.prevParent, v = J(o, ["originBox", "targetBox", "visibilityAction", "shouldStackAnimate", "onComplete", "prevParent"]), d = e.props, c = d.visualElement, y = d.layout;
+        if (s === !1)
+          return e.isAnimatingTree = !1, e.safeToRemove();
+        if (!(e.isAnimatingTree && s !== !0)) {
+          s && (e.isAnimatingTree = !0), a = i || a, n = u || n;
+          var p = !1, g = c.getProjectionParent();
+          if (g) {
+            var S = g.prevViewportBox, M = g.getLayoutState().layout;
+            m && (u && (M = m.getLayoutState().layout), i && !Ds(m, g) && m.prevViewportBox && (S = m.prevViewportBox)), S && ks(m, i, u) && (p = !0, a = Lt(S, a), n = Lt(M, n));
+          }
+          var L = Js(a, n), x = G(function(T) {
+            var w, C;
+            if (y === "position") {
+              var A = n[T].max - n[T].min;
+              a[T].max = a[T].min + A;
+            }
+            if (!c.projection.isTargetLocked)
+              if (f !== void 0)
+                c.setVisibility(f === Qr.Show);
+              else return L ? e.animateAxis(T, n[T], a[T], h(h({}, v), { isRelative: p })) : ((C = (w = e.stopAxisAnimation)[T]) === null || C === void 0 || C.call(w), c.setProjectionTargetAxis(T, n[T].min, n[T].max, p));
+          });
+          return c.syncRender(), Promise.all(x).then(function() {
+            e.isAnimatingTree = !1, l && l(), c.notifyLayoutAnimationComplete();
+          });
+        }
+      }, e;
+    }
+    return r.prototype.componentDidMount = function() {
+      var e = this, n = this.props.visualElement;
+      n.animateMotionValue = gr, n.enableLayoutProjection(), this.unsubLayoutReady = n.onLayoutUpdate(this.animate), n.layoutSafeToRemove = function() {
+        return e.safeToRemove();
+      }, Oo(Zs);
+    }, r.prototype.componentWillUnmount = function() {
+      var e = this;
+      this.unsubLayoutReady(), G(function(n) {
+        var a, o;
+        return (o = (a = e.stopAxisAnimation)[n]) === null || o === void 0 ? void 0 : o.call(a);
+      });
+    }, r.prototype.animateAxis = function(e, n, a, o) {
+      var i = this, u, f, s = o === void 0 ? {} : o, l = s.transition, m = s.isRelative;
+      if (!(this.isAnimating[e] && Kt(n, this.currentAnimationTarget[e]))) {
+        (f = (u = this.stopAxisAnimation)[e]) === null || f === void 0 || f.call(u), this.isAnimating[e] = !0;
+        var v = this.props.visualElement, d = this.frameTarget[e], c = v.getProjectionAnimationProgress()[e];
+        c.clearListeners(), c.set(0), c.set(0);
+        var y = function() {
+          var M = c.get() / bn;
+          Ms(d, a, n, M), v.setProjectionTargetAxis(e, d.min, d.max, m);
+        };
+        y();
+        var p = c.onChange(y);
+        this.stopAxisAnimation[e] = function() {
+          i.isAnimating[e] = !1, c.stop(), p();
+        }, this.currentAnimationTarget[e] = n;
+        var g = l || v.getDefaultTransition() || Qs, S = gr(e === "x" ? "layoutX" : "layoutY", c, bn, g && be(g, "layout")).then(this.stopAxisAnimation[e]);
+        return S;
+      }
+    }, r.prototype.safeToRemove = function() {
+      var e, n;
+      (n = (e = this.props).safeToRemove) === null || n === void 0 || n.call(e);
+    }, r.prototype.render = function() {
+      return null;
+    }, r;
+  }(St.Component)
+);
+function qs(t) {
+  var r = H(Dn(), 2), e = r[1];
+  return St.createElement($s, h({}, t, { safeToRemove: e }));
+}
+function Js(t, r) {
+  return !xn(t) && !xn(r) && (!Kt(t.x, r.x) || !Kt(t.y, r.y));
+}
+var Pn = { min: 0, max: 0 };
+function xn(t) {
+  return Kt(t.x, Pn) && Kt(t.y, Pn);
+}
+function Kt(t, r) {
+  return t.min === r.min && t.max === r.max;
+}
+var Qs = {
+  duration: 0.45,
+  ease: [0.4, 0, 0.1, 1]
+};
+function ks(t, r, e) {
+  return t || !t && !(r || e);
+}
+var tf = {
+  layoutReady: function(t) {
+    return t.notifyLayoutReady();
+  }
+};
+function Ja() {
+  var t = /* @__PURE__ */ new Set();
+  return {
+    add: function(r) {
+      return t.add(r);
+    },
+    flush: function(r) {
+      var e = r === void 0 ? tf : r, n = e.layoutReady, a = e.parent;
+      qr(function(o, i) {
+        var u = Array.from(t).sort(xe), f = a ? hr(a) : [];
+        i(function() {
+          var s = W(W([], H(f)), H(u));
+          s.forEach(function(l) {
+            return l.resetTransform();
+          });
+        }), o(function() {
+          u.forEach(sr);
+        }), i(function() {
+          f.forEach(function(s) {
+            return s.restoreTransform();
+          }), u.forEach(n);
+        }), o(function() {
+          u.forEach(function(s) {
+            s.isPresent && (s.presence = _t.Present);
+          });
+        }), i(function() {
+          Tt.preRender(), Tt.render();
+        }), o(function() {
+          nt.postRender(function() {
+            return u.forEach(rf);
+          }), t.clear();
+        });
+      }), Jr();
+    }
+  };
+}
+function rf(t) {
+  t.prevViewportBox = t.projection.target;
+}
+var ef = pt(Ja()), nf = pt(Ja());
+function bt(t) {
+  return !!t.forceUpdate;
+}
+var af = (
+  /** @class */
+  function(t) {
+    Ln(r, t);
+    function r() {
+      return t !== null && t.apply(this, arguments) || this;
+    }
+    return r.prototype.componentDidMount = function() {
+      var e = this.props, n = e.syncLayout, a = e.framerSyncLayout, o = e.visualElement;
+      bt(n) && n.register(o), bt(a) && a.register(o), o.onUnmount(function() {
+        bt(n) && n.remove(o), bt(a) && a.remove(o);
+      });
+    }, r.prototype.getSnapshotBeforeUpdate = function() {
+      var e = this.props, n = e.syncLayout, a = e.visualElement;
+      return bt(n) ? n.syncUpdate() : (Es(a), n.add(a)), null;
+    }, r.prototype.componentDidUpdate = function() {
+      var e = this.props.syncLayout;
+      bt(e) || e.flush();
+    }, r.prototype.render = function() {
+      return null;
+    }, r;
+  }(wn.Component)
+);
+function of(t) {
+  var r = z(ef), e = z(nf);
+  return wn.createElement(af, h({}, t, { syncLayout: r, framerSyncLayout: e }));
+}
+var uf = {
+  measureLayout: of,
+  layoutAnimation: qs
+}, sf = function() {
+  return {
+    isEnabled: !1,
+    isHydrated: !1,
+    isTargetLocked: !1,
+    target: ft(),
+    targetFinal: ft()
+  };
+};
+function Qa() {
+  return {
+    isHydrated: !1,
+    layout: ft(),
+    layoutCorrected: ft(),
+    treeScale: { x: 1, y: 1 },
+    delta: Qe(),
+    deltaFinal: Qe(),
+    deltaTransform: ""
+  };
+}
+var Tn = Qa();
+function wr(t, r, e) {
+  var n = t.x, a = t.y, o = n.translate / r.x, i = a.translate / r.y, u = "translate3d(" + o + "px, " + i + "px, 0) ";
+  if (e) {
+    var f = e.rotate, s = e.rotateX, l = e.rotateY;
+    f && (u += "rotate(" + f + ") "), s && (u += "rotateX(" + s + ") "), l && (u += "rotateY(" + l + ") ");
+  }
+  return u += "scale(" + n.scale + ", " + a.scale + ")", !e && u === ff ? "" : u;
+}
+function ka(t) {
+  var r = t.deltaFinal;
+  return r.x.origin * 100 + "% " + r.y.origin * 100 + "% 0";
+}
+var ff = wr(Tn.delta, Tn.treeScale, { x: 1, y: 1 }), nr = [
+  "LayoutMeasure",
+  "BeforeLayoutMeasure",
+  "LayoutUpdate",
+  "ViewportBoxUpdate",
+  "Update",
+  "Render",
+  "AnimationComplete",
+  "LayoutAnimationComplete",
+  "AnimationStart",
+  "SetAxisTarget",
+  "Unmount"
+];
+function lf() {
+  var t = nr.map(function() {
+    return new ur();
+  }), r = {}, e = {
+    clearAllListeners: function() {
+      return t.forEach(function(n) {
+        return n.clear();
+      });
+    },
+    updatePropListeners: function(n) {
+      return nr.forEach(function(a) {
+        var o;
+        (o = r[a]) === null || o === void 0 || o.call(r);
+        var i = "on" + a, u = n[i];
+        u && (r[a] = e[i](u));
+      });
+    }
+  };
+  return t.forEach(function(n, a) {
+    e["on" + nr[a]] = function(o) {
+      return n.add(o);
+    }, e["notify" + nr[a]] = function() {
+      for (var o = [], i = 0; i < arguments.length; i++)
+        o[i] = arguments[i];
+      return n.notify.apply(n, W([], H(o)));
+    };
+  }), e;
+}
+function cf(t, r, e) {
+  var n;
+  for (var a in r) {
+    var o = r[a], i = e[a];
+    if (st(o))
+      t.addValue(a, o);
+    else if (st(i))
+      t.addValue(a, mt(o));
+    else if (i !== o)
+      if (t.hasValue(a)) {
+        var u = t.getValue(a);
+        !u.hasAnimated && u.set(o);
+      } else
+        t.addValue(a, mt((n = t.getStaticValue(a)) !== null && n !== void 0 ? n : o));
+  }
+  for (var a in e)
+    r[a] === void 0 && t.removeValue(a);
+  return r;
+}
+function vf(t, r, e, n) {
+  var a = t.delta, o = t.layout, i = t.layoutCorrected, u = t.treeScale, f = r.target;
+  Rs(i, o), Bs(i, u, e), Ya(a, i, f, n);
+}
+var df = (
+  /** @class */
+  function() {
+    function t() {
+      this.children = [], this.isDirty = !1;
+    }
+    return t.prototype.add = function(r) {
+      Oa(this.children, r), this.isDirty = !0;
+    }, t.prototype.remove = function(r) {
+      Ia(this.children, r), this.isDirty = !0;
+    }, t.prototype.forEach = function(r) {
+      this.isDirty && this.children.sort(xe), this.isDirty = !1, this.children.forEach(r);
+    }, t;
+  }()
+);
+function mf(t) {
+  var r = t.getProjectionParent();
+  if (!r) {
+    t.rebaseProjectionTarget();
+    return;
+  }
+  var e = Lt(r.getLayoutState().layout, t.getLayoutState().layout);
+  G(function(n) {
+    t.setProjectionTargetAxis(n, e[n].min, e[n].max, !0);
+  });
+}
+var to = function(t) {
+  var r = t.treeType, e = r === void 0 ? "" : r, n = t.build, a = t.getBaseTarget, o = t.makeTargetAnimatable, i = t.measureViewportBox, u = t.render, f = t.readValueFromInstance, s = t.resetTransform, l = t.restoreTransform, m = t.removeValueFromRenderState, v = t.sortNodePosition, d = t.scrapeMotionValuesFromProps;
+  return function(c, y) {
+    var p = c.parent, g = c.props, S = c.presenceId, M = c.blockInitialAnimation, L = c.visualState;
+    y === void 0 && (y = {});
+    var x = L.latestValues, T = L.renderState, w, C = lf(), A = sf(), D, R = A, j = x, U, B = Qa(), Q, O = !1, $ = /* @__PURE__ */ new Map(), q = /* @__PURE__ */ new Map(), ht = {}, tt, _ = h({}, x), et;
+    function lt() {
+      w && (V.isProjectionReady() && ($r(R.targetFinal, R.target, j), Ya(B.deltaFinal, B.layoutCorrected, R.targetFinal, x)), ct(), u(w, T));
+    }
+    function ct() {
+      var b = x;
+      if (Q && Q.isActive()) {
+        var P = Q.getCrossfadeState(V);
+        P && (b = P);
+      }
+      n(V, T, b, R, B, y, g);
+    }
+    function Te() {
+      C.notifyUpdate(x);
+    }
+    function oo() {
+      if (V.isProjectionReady()) {
+        var b = B.delta, P = B.treeScale, I = P.x, N = P.y, K = B.deltaTransform;
+        vf(B, R, V.path, x), O && V.notifyViewportBoxUpdate(R.target, b), O = !1;
+        var k = wr(b, P);
+        (k !== K || // Also compare calculated treeScale, for values that rely on this only for scale correction
+        I !== P.x || N !== P.y) && V.scheduleRender(), B.deltaTransform = k;
+      }
+    }
+    function io() {
+      V.layoutTree.forEach(gf);
+    }
+    function uo(b, P) {
+      var I = P.onChange(function(K) {
+        x[b] = K, g.onUpdate && nt.update(Te, !1, !0);
+      }), N = P.onRenderRequest(V.scheduleRender);
+      q.set(b, function() {
+        I(), N();
+      });
+    }
+    var Se = d(g);
+    for (var Er in Se) {
+      var Ae = Se[Er];
+      x[Er] !== void 0 && st(Ae) && Ae.set(x[Er], !1);
+    }
+    var Ve = Ar(g), Mr = In(g), V = h(h({
+      treeType: e,
+      /**
+       * 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: p ? p.depth + 1 : 0,
+      parent: p,
+      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: p ? W(W([], H(p.path)), [p]) : [],
+      layoutTree: p ? p.layoutTree : new df(),
+      /**
+       *
+       */
+      presenceId: S,
+      projection: A,
+      /**
+       * 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: Mr ? /* @__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: !!(p != null && p.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: M,
+      /**
+       * 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(b) {
+        w = V.current = b, V.pointTo(V), Mr && p && !Ve && (et = p == null ? void 0 : p.addVariantChild(V)), p == null || p.children.add(V);
+      },
+      /**
+       *
+       */
+      unmount: function() {
+        Rt.update(Te), Rt.render(lt), Rt.preRender(V.updateLayoutProjection), q.forEach(function(b) {
+          return b();
+        }), V.stopLayoutAnimation(), V.layoutTree.remove(V), et == null || et(), p == null || p.children.delete(V), U == null || U(), C.clearAllListeners();
+      },
+      /**
+       * Add a child visual element to our set of children.
+       */
+      addVariantChild: function(b) {
+        var P, I = V.getClosestVariantNode();
+        if (I)
+          return (P = I.variantChildren) === null || P === void 0 || P.add(b), function() {
+            return I.variantChildren.delete(b);
+          };
+      },
+      sortNodePosition: function(b) {
+        return !v || e !== b.treeType ? 0 : v(V.getInstance(), b.getInstance());
+      },
+      /**
+       * Returns the closest variant node in the tree starting from
+       * this visual element.
+       */
+      getClosestVariantNode: function() {
+        return Mr ? V : p == null ? void 0 : p.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: p ? p.scheduleUpdateLayoutProjection : function() {
+        return nt.preRender(V.updateTreeLayoutProjection, !1, !0);
+      },
+      /**
+       * Expose the latest layoutId prop.
+       */
+      getLayoutId: function() {
+        return g.layoutId;
+      },
+      /**
+       * Returns the current instance.
+       */
+      getInstance: function() {
+        return w;
+      },
+      /**
+       * Get/set the latest static values.
+       */
+      getStaticValue: function(b) {
+        return x[b];
+      },
+      setStaticValue: function(b, P) {
+        return x[b] = P;
+      },
+      /**
+       * 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 x;
+      },
+      /**
+       * Set the visiblity of the visual element. If it's changed, schedule
+       * a render to reflect these changes.
+       */
+      setVisibility: function(b) {
+        V.isVisible !== b && (V.isVisible = b, V.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(b, P) {
+        return P === void 0 && (P = !0), o(V, b, g, P);
+      },
+      // Motion values ========================
+      /**
+       * Add a motion value and bind it to this visual element.
+       */
+      addValue: function(b, P) {
+        V.hasValue(b) && V.removeValue(b), $.set(b, P), x[b] = P.get(), uo(b, P);
+      },
+      /**
+       * Remove a motion value and unbind any active subscriptions.
+       */
+      removeValue: function(b) {
+        var P;
+        $.delete(b), (P = q.get(b)) === null || P === void 0 || P(), q.delete(b), delete x[b], m(b, T);
+      },
+      /**
+       * Check whether we have a motion value for this key
+       */
+      hasValue: function(b) {
+        return $.has(b);
+      },
+      /**
+       * Get a motion value for this key. If called with a default
+       * value, we'll create one if none exists.
+       */
+      getValue: function(b, P) {
+        var I = $.get(b);
+        return I === void 0 && P !== void 0 && (I = mt(P), V.addValue(b, I)), I;
+      },
+      /**
+       * Iterate over our motion values.
+       */
+      forEachValue: function(b) {
+        return $.forEach(b);
+      },
+      /**
+       * 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(b) {
+        var P;
+        return (P = x[b]) !== null && P !== void 0 ? P : f(w, b, y);
+      },
+      /**
+       * 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(b, P) {
+        _[b] = P;
+      },
+      /**
+       * Find the base target for a value thats been removed from all animation
+       * props.
+       */
+      getBaseTarget: function(b) {
+        if (a) {
+          var P = a(g, b);
+          if (P !== void 0 && !st(P))
+            return P;
+        }
+        return _[b];
+      }
+    }, C), {
+      /**
+       * Build the renderer state based on the latest visual state.
+       */
+      build: function() {
+        return ct(), T;
+      },
+      /**
+       * Schedule a render on the next animation frame.
+       */
+      scheduleRender: function() {
+        nt.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(b) {
+        g = b, C.updatePropListeners(b), ht = cf(V, d(g), ht);
+      },
+      getProps: function() {
+        return g;
+      },
+      // Variants ==============================
+      /**
+       * Returns the variant definition with a given name.
+       */
+      getVariant: function(b) {
+        var P;
+        return (P = g.variants) === null || P === void 0 ? void 0 : P[b];
+      },
+      /**
+       * Returns the defined default transition on this component.
+       */
+      getDefaultTransition: function() {
+        return g.transition;
+      },
+      /**
+       * Used by child variant nodes to get the closest ancestor variant props.
+       */
+      getVariantContext: function(b) {
+        if (b === void 0 && (b = !1), b)
+          return p == null ? void 0 : p.getVariantContext();
+        if (!Ve) {
+          var P = (p == null ? void 0 : p.getVariantContext()) || {};
+          return g.initial !== void 0 && (P.initial = g.initial), P;
+        }
+        for (var I = {}, N = 0; N < hf; N++) {
+          var K = ro[N], k = g[K];
+          (rt(k) || k === !1) && (I[K] = k);
+        }
+        return I;
+      },
+      // Layout projection ==============================
+      /**
+       * Enable layout projection for this visual element. Won't actually
+       * occur until we also have hydrated layout measurements.
+       */
+      enableLayoutProjection: function() {
+        A.isEnabled = !0, V.layoutTree.add(V);
+      },
+      /**
+       * Lock the projection target, for instance when dragging, so
+       * nothing else can try and animate it.
+       */
+      lockProjectionTarget: function() {
+        A.isTargetLocked = !0;
+      },
+      unlockProjectionTarget: function() {
+        V.stopLayoutAnimation(), A.isTargetLocked = !1;
+      },
+      getLayoutState: function() {
+        return B;
+      },
+      setCrossfader: function(b) {
+        Q = b;
+      },
+      isProjectionReady: function() {
+        return A.isEnabled && A.isHydrated && B.isHydrated;
+      },
+      /**
+       * Start a layout animation on a given axis.
+       */
+      startLayoutAnimation: function(b, P, I) {
+        I === void 0 && (I = !1);
+        var N = V.getProjectionAnimationProgress()[b], K = I ? A.relativeTarget[b] : A.target[b], k = K.min, Zt = K.max, $t = Zt - k;
+        return N.clearListeners(), N.set(k), N.set(k), N.onChange(function(qt) {
+          V.setProjectionTargetAxis(b, qt, qt + $t, I);
+        }), V.animateMotionValue(b, N, 0, P);
+      },
+      /**
+       * Stop layout animations.
+       */
+      stopLayoutAnimation: function() {
+        G(function(b) {
+          return V.getProjectionAnimationProgress()[b].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(b) {
+        b === void 0 && (b = !0);
+        var P = i(w, y);
+        return b || $a(P, x), P;
+      },
+      /**
+       * Get the motion values tracking the layout animations on each
+       * axis. Lazy init if not already created.
+       */
+      getProjectionAnimationProgress: function() {
+        return tt || (tt = {
+          x: mt(0),
+          y: mt(0)
+        }), tt;
+      },
+      /**
+       * Update the projection of a single axis. Schedule an update to
+       * the tree layout projection.
+       */
+      setProjectionTargetAxis: function(b, P, I, N) {
+        N === void 0 && (N = !1);
+        var K;
+        N ? (A.relativeTarget || (A.relativeTarget = ft()), K = A.relativeTarget[b]) : (A.relativeTarget = void 0, K = A.target[b]), A.isHydrated = !0, K.min = P, K.max = I, O = !0, C.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(b, P) {
+        P === void 0 && (P = B.layout);
+        var I = V.getProjectionAnimationProgress(), N = I.x, K = I.y, k = !A.relativeTarget && !A.isTargetLocked && !N.isAnimating() && !K.isAnimating();
+        (b || k) && G(function(Zt) {
+          var $t = P[Zt], qt = $t.min, so = $t.max;
+          V.setProjectionTargetAxis(Zt, qt, so);
+        });
+      },
+      /**
+       * 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(b) {
+        mf(V), V.notifyLayoutUpdate(B.layout, V.prevViewportBox || B.layout, b);
+      },
+      /**
+       * Temporarily reset the transform of the instance.
+       */
+      resetTransform: function() {
+        return s(V, w, g);
+      },
+      restoreTransform: function() {
+        return l(w, T);
+      },
+      updateLayoutProjection: oo,
+      updateTreeLayoutProjection: function() {
+        V.layoutTree.forEach(pf), nt.preRender(io, !1, !0);
+      },
+      getProjectionParent: function() {
+        if (D === void 0) {
+          for (var b = !1, P = V.path.length - 1; P >= 0; P--) {
+            var I = V.path[P];
+            if (I.projection.isEnabled) {
+              b = I;
+              break;
+            }
+          }
+          D = b;
+        }
+        return D;
+      },
+      resolveRelativeTargetBox: function() {
+        var b = V.getProjectionParent();
+        if (!(!A.relativeTarget || !b) && (Ls(A, b.projection), Xa(b))) {
+          var P = A.target;
+          $r(P, P, b.getLatestValues());
+        }
+      },
+      shouldResetTransform: function() {
+        return !!g._layoutResetTransform;
+      },
+      /**
+       *
+       */
+      pointTo: function(b) {
+        R = b.projection, j = b.getLatestValues(), U == null || U(), U = Xt(b.onSetAxisTarget(V.scheduleUpdateLayoutProjection), b.onLayoutAnimationComplete(function() {
+          var P;
+          V.isPresent ? V.presence = _t.Present : (P = V.layoutSafeToRemove) === null || P === void 0 || P.call(V);
+        }));
+      },
+      // TODO: Clean this up
+      isPresent: !0,
+      presence: _t.Entering
+    });
+    return V;
+  };
+};
+function pf(t) {
+  t.resolveRelativeTargetBox();
+}
+function gf(t) {
+  t.updateLayoutProjection();
+}
+var ro = W(["initial"], H(Pe)), hf = ro.length, yf = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "x",
+  "y"
+]), eo = function(t) {
+  return yf.has(t);
+}, bf = function(t) {
+  return Object.keys(t).some(eo);
+}, no = function(t, r) {
+  t.set(r, !1), t.set(r);
+}, ar = function(t) {
+  return t === gt || t === E;
+}, Sn;
+(function(t) {
+  t.width = "width", t.height = "height", t.left = "left", t.right = "right", t.top = "top", t.bottom = "bottom";
+})(Sn || (Sn = {}));
+var An = function(t, r) {
+  return parseFloat(t.split(", ")[r]);
+}, Vn = function(t, r) {
+  return function(e, n) {
+    var a = n.transform;
+    if (a === "none" || !a)
+      return 0;
+    var o = a.match(/^matrix3d\((.+)\)$/);
+    if (o)
+      return An(o[1], r);
+    var i = a.match(/^matrix\((.+)\)$/);
+    return i ? An(i[1], t) : 0;
+  };
+}, Pf = /* @__PURE__ */ new Set(["x", "y", "z"]), xf = Bt.filter(function(t) {
+  return !Pf.has(t);
+});
+function Tf(t) {
+  var r = [];
+  return xf.forEach(function(e) {
+    var n = t.getValue(e);
+    n !== void 0 && (r.push([e, n.get()]), n.set(e.startsWith("scale") ? 1 : 0));
+  }), r.length && t.syncRender(), r;
+}
+var Cn = {
+  // Dimensions
+  width: function(t) {
+    var r = t.x;
+    return r.max - r.min;
+  },
+  height: function(t) {
+    var r = t.y;
+    return r.max - r.min;
+  },
+  top: function(t, r) {
+    var e = r.top;
+    return parseFloat(e);
+  },
+  left: function(t, r) {
+    var e = r.left;
+    return parseFloat(e);
+  },
+  bottom: function(t, r) {
+    var e = t.y, n = r.top;
+    return parseFloat(n) + (e.max - e.min);
+  },
+  right: function(t, r) {
+    var e = t.x, n = r.left;
+    return parseFloat(n) + (e.max - e.min);
+  },
+  // Transform
+  x: Vn(4, 13),
+  y: Vn(5, 14)
+}, Sf = function(t, r, e) {
+  var n = r.measureViewportBox(), a = r.getInstance(), o = getComputedStyle(a), i = o.display, u = o.top, f = o.left, s = o.bottom, l = o.right, m = o.transform, v = { top: u, left: f, bottom: s, right: l, transform: m };
+  i === "none" && r.setStaticValue("display", t.display || "block"), r.syncRender();
+  var d = r.measureViewportBox();
+  return e.forEach(function(c) {
+    var y = r.getValue(c);
+    no(y, Cn[c](n, v)), t[c] = Cn[c](d, o);
+  }), t;
+}, Af = function(t, r, e, n) {
+  e === void 0 && (e = {}), n === void 0 && (n = {}), r = h({}, r), n = h({}, n);
+  var a = Object.keys(r).filter(eo), o = [], i = !1, u = [];
+  if (a.forEach(function(s) {
+    var l = t.getValue(s);
+    if (t.hasValue(s)) {
+      var m = e[s], v = r[s], d = rr(m), c;
+      if (jt(v))
+        for (var y = v.length, p = v[0] === null ? 1 : 0; p < y; p++)
+          c ? X(rr(v[p]) === c, "All keyframes must be of the same type") : (c = rr(v[p]), X(c === d || ar(d) && ar(c), "Keyframes must be of the same dimension as the current value"));
+      else
+        c = rr(v);
+      if (d !== c)
+        if (ar(d) && ar(c)) {
+          var g = l.get();
+          typeof g == "string" && l.set(parseFloat(g)), typeof v == "string" ? r[s] = parseFloat(v) : Array.isArray(v) && c === E && (r[s] = v.map(parseFloat));
+        } else d != null && d.transform && (c != null && c.transform) && (m === 0 || v === 0) ? m === 0 ? l.set(c.transform(m)) : r[s] = d.transform(v) : (i || (o = Tf(t), i = !0), u.push(s), n[s] = n[s] !== void 0 ? n[s] : r[s], no(l, v));
+    }
+  }), u.length) {
+    var f = Sf(r, t, u);
+    return o.length && o.forEach(function(s) {
+      var l = H(s, 2), m = l[0], v = l[1];
+      t.getValue(m).set(v);
+    }), t.syncRender(), { target: f, transitionEnd: n };
+  } else
+    return { target: r, transitionEnd: n };
+};
+function Vf(t, r, e, n) {
+  return bf(r) ? Af(t, r, e, n) : { target: r, transitionEnd: n };
+}
+var Cf = function(t, r, e, n) {
+  var a = Gs(t, r, n);
+  return r = a.target, n = a.transitionEnd, Vf(t, r, e, n);
+};
+function Lf(t) {
+  return window.getComputedStyle(t);
+}
+var ao = {
+  treeType: "dom",
+  readValueFromInstance: function(t, r) {
+    if (Vr(r)) {
+      var e = he(r);
+      return e && e.default || 0;
+    } else {
+      var n = Lf(t);
+      return (jn(r) ? n.getPropertyValue(r) : n[r]) || 0;
+    }
+  },
+  sortNodePosition: function(t, r) {
+    return t.compareDocumentPosition(r) & 2 ? 1 : -1;
+  },
+  getBaseTarget: function(t, r) {
+    var e;
+    return (e = t.style) === null || e === void 0 ? void 0 : e[r];
+  },
+  measureViewportBox: function(t, r) {
+    var e = r.transformPagePoint;
+    return za(t, e);
+  },
+  /**
+   * 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, r, e) {
+    var n = e.transformTemplate;
+    r.style.transform = n ? n({}, "") : "none", t.scheduleRender();
+  },
+  restoreTransform: function(t, r) {
+    t.style.transform = r.style.transform;
+  },
+  removeValueFromRenderState: function(t, r) {
+    var e = r.vars, n = r.style;
+    delete e[t], delete n[t];
+  },
+  /**
+   * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`
+   * can be animated by Motion.
+   */
+  makeTargetAnimatable: function(t, r, e, n) {
+    var a = e.transformValues;
+    n === void 0 && (n = !0);
+    var o = r.transition, i = r.transitionEnd, u = J(r, ["transition", "transitionEnd"]), f = rs(u, o || {}, t);
+    if (a && (i && (i = a(i)), u && (u = a(u)), f && (f = a(f))), n) {
+      ku(t, u, f);
+      var s = Cf(t, u, f, i);
+      i = s.transitionEnd, u = s.target;
+    }
+    return h({
+      transition: o,
+      transitionEnd: i
+    }, u);
+  },
+  scrapeMotionValuesFromProps: fe,
+  build: function(t, r, e, n, a, o, i) {
+    t.isVisible !== void 0 && (r.style.visibility = t.isVisible ? "visible" : "hidden");
+    var u = n.isEnabled && a.isHydrated;
+    ie(r, e, n, a, o, i.transformTemplate, u ? wr : void 0, u ? ka : void 0);
+  },
+  render: qn
+}, wf = to(ao), Ef = to(h(h({}, ao), {
+  getBaseTarget: function(t, r) {
+    return t[r];
+  },
+  readValueFromInstance: function(t, r) {
+    var e;
+    return Vr(r) ? ((e = he(r)) === null || e === void 0 ? void 0 : e.default) || 0 : (r = Jn.has(r) ? r : $n(r), t.getAttribute(r));
+  },
+  scrapeMotionValuesFromProps: kn,
+  build: function(t, r, e, n, a, o, i) {
+    var u = n.isEnabled && a.isHydrated;
+    se(r, e, n, a, o, i.transformTemplate, u ? wr : void 0, u ? ka : void 0);
+  },
+  render: Qn
+})), Mf = function(t, r) {
+  return ae(t) ? Ef(r, { enableHardwareAcceleration: !1 }) : wf(r, { enableHardwareAcceleration: !0 });
+}, Df = h(h(h(h({}, vs), Iu), Ks), uf), If = /* @__PURE__ */ Do(function(t, r) {
+  return Pi(t, r, Df, Mf);
+});
+export {
+  Tr as P,
+  ef as S,
+  ne as a,
+  bt as i,
+  If as m,
+  fa as u
+};