@tomo-inc/wallet-connect-kit 0.0.6 → 0.0.8

package/dist/features-animation-DUflHXKI.js

@@ -0,0 +1,2509 @@
+import { G as Ct, H as Z, I as Ie, d as q, J as Ee, e as Mt, K as Mn, p as Ae, N as Fn, O as Dn, Q as Rn, a as P, R as le, T as On, U as In, V as Ne, W as H, X as Ft, b as Y, Y as En, Z as Nn, f as ne, w as Dt, B as ue, n as I, c as se, _ as ce, $ as Kn, h as Bn, r as Rt, a0 as Ke, a1 as Ln, x as kn, a2 as _n, j as O, a3 as Ot, a4 as It, a5 as Et, a6 as He, a7 as Nt, E as Gn, a8 as Un, a9 as $n, aa as qe, ab as jn, ac as Wn, ad as zn, ae as Hn, af as qn, ag as Yn, ah as Xn, ai as Zn, aj as Jn, ak as Qn, al as es } from "./index-Dh-ZdA1s.js";
+import { Fragment as ts } from "react";
+function Kt(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let s = 0; s < n; s++)
+    if (e[s] !== t[s])
+      return !1;
+  return !0;
+}
+function he(t, e, n) {
+  const s = t.getProps();
+  return Ct(s, e, n !== void 0 ? n : s.custom, t);
+}
+const R = (t) => t * 1e3, E = (t) => t / 1e3, ns = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, ss = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), is = {
+  type: "keyframes",
+  duration: 0.8
+}, rs = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, os = (t, { keyframes: e }) => e.length > 2 ? is : Z.has(t) ? t.startsWith("scale") ? ss(e[1]) : ns : rs;
+function as({ when: t, delay: e, delayChildren: n, staggerChildren: s, staggerDirection: i, repeat: r, repeatType: o, repeatDelay: l, from: a, elapsed: u, ...h }) {
+  return !!Object.keys(h).length;
+}
+function Bt(t, e) {
+  return t[e] || t.default || t;
+}
+const ls = (t) => t !== null;
+function de(t, { repeat: e, repeatType: n = "loop" }, s) {
+  const i = t.filter(ls), r = e && n !== "loop" && e % 2 === 1 ? 0 : i.length - 1;
+  return !r || s === void 0 ? i[r] : s;
+}
+const Lt = (t) => /^0[^.\s]+$/u.test(t);
+function us(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || Lt(t) : !0;
+}
+const kt = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t), cs = (
+  // eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
+  /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
+);
+function hs(t) {
+  const e = cs.exec(t);
+  if (!e)
+    return [,];
+  const [, n, s, i] = e;
+  return [`--${n ?? s}`, i];
+}
+const ds = 4;
+function _t(t, e, n = 1) {
+  q(n <= ds, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`);
+  const [s, i] = hs(t);
+  if (!s)
+    return;
+  const r = window.getComputedStyle(e).getPropertyValue(s);
+  if (r) {
+    const o = r.trim();
+    return kt(o) ? parseFloat(o) : o;
+  }
+  return Ie(i) ? _t(i, e, n + 1) : i;
+}
+const fs = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "x",
+  "y",
+  "translateX",
+  "translateY"
+]), Ye = (t) => t === Ee || t === Mt, Xe = (t, e) => parseFloat(t.split(", ")[e]), Ze = (t, e) => (n, { transform: s }) => {
+  if (s === "none" || !s)
+    return 0;
+  const i = s.match(/^matrix3d\((.+)\)$/u);
+  if (i)
+    return Xe(i[1], e);
+  {
+    const r = s.match(/^matrix\((.+)\)$/u);
+    return r ? Xe(r[1], t) : 0;
+  }
+}, ps = /* @__PURE__ */ new Set(["x", "y", "z"]), ms = Mn.filter((t) => !ps.has(t));
+function gs(t) {
+  const e = [];
+  return ms.forEach((n) => {
+    const s = t.getValue(n);
+    s !== void 0 && (e.push([n, s.get()]), s.set(n.startsWith("scale") ? 1 : 0));
+  }), e;
+}
+const $ = {
+  // Dimensions
+  width: ({ x: t }, { paddingLeft: e = "0", paddingRight: n = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(n),
+  height: ({ y: t }, { paddingTop: e = "0", paddingBottom: n = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(n),
+  top: (t, { top: e }) => parseFloat(e),
+  left: (t, { left: e }) => parseFloat(e),
+  bottom: ({ y: t }, { top: e }) => parseFloat(e) + (t.max - t.min),
+  right: ({ x: t }, { left: e }) => parseFloat(e) + (t.max - t.min),
+  // Transform
+  x: Ze(4, 13),
+  y: Ze(5, 14)
+};
+$.translateX = $.x;
+$.translateY = $.y;
+const Gt = (t) => (e) => e.test(t), vs = {
+  test: (t) => t === "auto",
+  parse: (t) => t
+}, Ut = [Ee, Mt, Ae, Fn, Dn, Rn, vs], Je = (t) => Ut.find(Gt(t)), _ = /* @__PURE__ */ new Set();
+let Se = !1, we = !1;
+function $t() {
+  if (we) {
+    const t = Array.from(_).filter((s) => s.needsMeasurement), e = new Set(t.map((s) => s.element)), n = /* @__PURE__ */ new Map();
+    e.forEach((s) => {
+      const i = gs(s);
+      i.length && (n.set(s, i), s.render());
+    }), t.forEach((s) => s.measureInitialState()), e.forEach((s) => {
+      s.render();
+      const i = n.get(s);
+      i && i.forEach(([r, o]) => {
+        var l;
+        (l = s.getValue(r)) === null || l === void 0 || l.set(o);
+      });
+    }), t.forEach((s) => s.measureEndState()), t.forEach((s) => {
+      s.suspendedScrollY !== void 0 && window.scrollTo(0, s.suspendedScrollY);
+    });
+  }
+  we = !1, Se = !1, _.forEach((t) => t.complete()), _.clear();
+}
+function jt() {
+  _.forEach((t) => {
+    t.readKeyframes(), t.needsMeasurement && (we = !0);
+  });
+}
+function ys() {
+  jt(), $t();
+}
+class Be {
+  constructor(e, n, s, i, r, o = !1) {
+    this.isComplete = !1, this.isAsync = !1, this.needsMeasurement = !1, this.isScheduled = !1, this.unresolvedKeyframes = [...e], this.onComplete = n, this.name = s, this.motionValue = i, this.element = r, this.isAsync = o;
+  }
+  scheduleResolve() {
+    this.isScheduled = !0, this.isAsync ? (_.add(this), Se || (Se = !0, P.read(jt), P.resolveKeyframes($t))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, name: n, element: s, motionValue: i } = this;
+    for (let r = 0; r < e.length; r++)
+      if (e[r] === null)
+        if (r === 0) {
+          const o = i?.get(), l = e[e.length - 1];
+          if (o !== void 0)
+            e[0] = o;
+          else if (s && n) {
+            const a = s.readValue(n, l);
+            a != null && (e[0] = a);
+          }
+          e[0] === void 0 && (e[0] = l), i && o === void 0 && i.set(e[0]);
+        } else
+          e[r] = e[r - 1];
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete() {
+    this.isComplete = !0, this.onComplete(this.unresolvedKeyframes, this.finalKeyframe), _.delete(this);
+  }
+  cancel() {
+    this.isComplete || (this.isScheduled = !1, _.delete(this));
+  }
+  resume() {
+    this.isComplete || this.scheduleResolve();
+  }
+}
+const Le = (t, e) => (n) => !!(le(n) && On.test(n) && n.startsWith(t) || e && !In(n) && Object.prototype.hasOwnProperty.call(n, e)), Wt = (t, e, n) => (s) => {
+  if (!le(s))
+    return s;
+  const [i, r, o, l] = s.match(Ne);
+  return {
+    [t]: parseFloat(i),
+    [e]: parseFloat(r),
+    [n]: parseFloat(o),
+    alpha: l !== void 0 ? parseFloat(l) : 1
+  };
+}, bs = (t) => Y(0, 255, t), me = {
+  ...Ee,
+  transform: (t) => Math.round(bs(t))
+}, L = {
+  test: /* @__PURE__ */ Le("rgb", "red"),
+  parse: /* @__PURE__ */ Wt("red", "green", "blue"),
+  transform: ({ red: t, green: e, blue: n, alpha: s = 1 }) => "rgba(" + me.transform(t) + ", " + me.transform(e) + ", " + me.transform(n) + ", " + H(Ft.transform(s)) + ")"
+};
+function Ts(t) {
+  let e = "", n = "", s = "", i = "";
+  return t.length > 5 ? (e = t.substring(1, 3), n = t.substring(3, 5), s = t.substring(5, 7), i = t.substring(7, 9)) : (e = t.substring(1, 2), n = t.substring(2, 3), s = t.substring(3, 4), i = t.substring(4, 5), e += e, n += n, s += s, i += i), {
+    red: parseInt(e, 16),
+    green: parseInt(n, 16),
+    blue: parseInt(s, 16),
+    alpha: i ? parseInt(i, 16) / 255 : 1
+  };
+}
+const xe = {
+  test: /* @__PURE__ */ Le("#"),
+  parse: Ts,
+  transform: L.transform
+}, U = {
+  test: /* @__PURE__ */ Le("hsl", "hue"),
+  parse: /* @__PURE__ */ Wt("hue", "saturation", "lightness"),
+  transform: ({ hue: t, saturation: e, lightness: n, alpha: s = 1 }) => "hsla(" + Math.round(t) + ", " + Ae.transform(H(e)) + ", " + Ae.transform(H(n)) + ", " + H(Ft.transform(s)) + ")"
+}, w = {
+  test: (t) => L.test(t) || xe.test(t) || U.test(t),
+  parse: (t) => L.test(t) ? L.parse(t) : U.test(t) ? U.parse(t) : xe.parse(t),
+  transform: (t) => le(t) ? t : t.hasOwnProperty("red") ? L.transform(t) : U.transform(t)
+};
+function Vs(t) {
+  var e, n;
+  return isNaN(t) && le(t) && (((e = t.match(Ne)) === null || e === void 0 ? void 0 : e.length) || 0) + (((n = t.match(En)) === null || n === void 0 ? void 0 : n.length) || 0) > 0;
+}
+const zt = "number", Ht = "color", As = "var", Ss = "var(", Qe = "${}", ws = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function X(t) {
+  const e = t.toString(), n = [], s = {
+    color: [],
+    number: [],
+    var: []
+  }, i = [];
+  let r = 0;
+  const l = e.replace(ws, (a) => (w.test(a) ? (s.color.push(r), i.push(Ht), n.push(w.parse(a))) : a.startsWith(Ss) ? (s.var.push(r), i.push(As), n.push(a)) : (s.number.push(r), i.push(zt), n.push(parseFloat(a))), ++r, Qe)).split(Qe);
+  return { values: n, split: l, indexes: s, types: i };
+}
+function qt(t) {
+  return X(t).values;
+}
+function Yt(t) {
+  const { split: e, types: n } = X(t), s = e.length;
+  return (i) => {
+    let r = "";
+    for (let o = 0; o < s; o++)
+      if (r += e[o], i[o] !== void 0) {
+        const l = n[o];
+        l === zt ? r += H(i[o]) : l === Ht ? r += w.transform(i[o]) : r += i[o];
+      }
+    return r;
+  };
+}
+const xs = (t) => typeof t == "number" ? 0 : t;
+function Ps(t) {
+  const e = qt(t);
+  return Yt(t)(e.map(xs));
+}
+const j = {
+  test: Vs,
+  parse: qt,
+  createTransformer: Yt,
+  getAnimatableNone: Ps
+}, Cs = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function Ms(t) {
+  const [e, n] = t.slice(0, -1).split("(");
+  if (e === "drop-shadow")
+    return t;
+  const [s] = n.match(Ne) || [];
+  if (!s)
+    return t;
+  const i = n.replace(s, "");
+  let r = Cs.has(e) ? 1 : 0;
+  return s !== n && (r *= 100), e + "(" + r + i + ")";
+}
+const Fs = /\b([a-z-]*)\(.*?\)/gu, Pe = {
+  ...j,
+  getAnimatableNone: (t) => {
+    const e = t.match(Fs);
+    return e ? e.map(Ms).join(" ") : t;
+  }
+}, Ds = {
+  ...Nn,
+  // Color props
+  color: w,
+  backgroundColor: w,
+  outlineColor: w,
+  fill: w,
+  stroke: w,
+  // Border props
+  borderColor: w,
+  borderTopColor: w,
+  borderRightColor: w,
+  borderBottomColor: w,
+  borderLeftColor: w,
+  filter: Pe,
+  WebkitFilter: Pe
+}, ke = (t) => Ds[t];
+function Xt(t, e) {
+  let n = ke(t);
+  return n !== Pe && (n = j), n.getAnimatableNone ? n.getAnimatableNone(e) : void 0;
+}
+const Rs = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function Os(t, e, n) {
+  let s = 0, i;
+  for (; s < t.length && !i; ) {
+    const r = t[s];
+    typeof r == "string" && !Rs.has(r) && X(r).values.length && (i = t[s]), s++;
+  }
+  if (i && n)
+    for (const r of e)
+      t[r] = Xt(n, i);
+}
+class Zt extends Be {
+  constructor(e, n, s, i, r) {
+    super(e, n, s, i, r, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: n, name: s } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let a = 0; a < e.length; a++) {
+      let u = e[a];
+      if (typeof u == "string" && (u = u.trim(), Ie(u))) {
+        const h = _t(u, n.current);
+        h !== void 0 && (e[a] = h), a === e.length - 1 && (this.finalKeyframe = u);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !fs.has(s) || e.length !== 2)
+      return;
+    const [i, r] = e, o = Je(i), l = Je(r);
+    if (o !== l)
+      if (Ye(o) && Ye(l))
+        for (let a = 0; a < e.length; a++) {
+          const u = e[a];
+          typeof u == "string" && (e[a] = parseFloat(u));
+        }
+      else
+        this.needsMeasurement = !0;
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, s = [];
+    for (let i = 0; i < e.length; i++)
+      us(e[i]) && s.push(i);
+    s.length && Os(e, s, n);
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: n, name: s } = this;
+    if (!e || !e.current)
+      return;
+    s === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = $[s](e.measureViewportBox(), window.getComputedStyle(e.current)), n[0] = this.measuredOrigin;
+    const i = n[n.length - 1];
+    i !== void 0 && e.getValue(s, i).jump(i, !1);
+  }
+  measureEndState() {
+    var e;
+    const { element: n, name: s, unresolvedKeyframes: i } = this;
+    if (!n || !n.current)
+      return;
+    const r = n.getValue(s);
+    r && r.jump(this.measuredOrigin, !1);
+    const o = i.length - 1, l = i[o];
+    i[o] = $[s](n.measureViewportBox(), window.getComputedStyle(n.current)), l !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = l), !((e = this.removedTransforms) === null || e === void 0) && e.length && this.removedTransforms.forEach(([a, u]) => {
+      n.getValue(a).set(u);
+    }), this.resolveNoneKeyframes();
+  }
+}
+function Jt(t) {
+  let e;
+  return () => (e === void 0 && (e = t()), e);
+}
+let ee;
+function Is() {
+  ee = void 0;
+}
+const N = {
+  now: () => (ee === void 0 && N.set(ne.isProcessing || Dt.useManualTiming ? ne.timestamp : performance.now()), ee),
+  set: (t) => {
+    ee = t, queueMicrotask(Is);
+  }
+}, et = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(j.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url("));
+function Es(t) {
+  const e = t[0];
+  if (t.length === 1)
+    return !0;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== e)
+      return !0;
+}
+function Ns(t, e, n, s) {
+  const i = t[0];
+  if (i === null)
+    return !1;
+  if (e === "display" || e === "visibility")
+    return !0;
+  const r = t[t.length - 1], o = et(i, e), l = et(r, e);
+  return ue(o === l, `You are trying to animate ${e} from "${i}" to "${r}". ${i} is not an animatable value - to enable this animation set ${i} to a value animatable to ${r} via the \`style\` property.`), !o || !l ? !1 : Es(t) || n === "spring" && s;
+}
+const Ks = 40;
+class Qt {
+  constructor({ autoplay: e = !0, delay: n = 0, type: s = "keyframes", repeat: i = 0, repeatDelay: r = 0, repeatType: o = "loop", ...l }) {
+    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = N.now(), this.options = {
+      autoplay: e,
+      delay: n,
+      type: s,
+      repeat: i,
+      repeatDelay: r,
+      repeatType: o,
+      ...l
+    }, this.updateFinishedPromise();
+  }
+  /**
+   * This method uses the createdAt and resolvedAt to calculate the
+   * animation startTime. *Ideally*, we would use the createdAt time as t=0
+   * as the following frame would then be the first frame of the animation in
+   * progress, which would feel snappier.
+   *
+   * However, if there's a delay (main thread work) between the creation of
+   * the animation and the first commited frame, we prefer to use resolvedAt
+   * to avoid a sudden jump into the animation.
+   */
+  calcStartTime() {
+    return this.resolvedAt ? this.resolvedAt - this.createdAt > Ks ? this.resolvedAt : this.createdAt : this.createdAt;
+  }
+  /**
+   * A getter for resolved data. If keyframes are not yet resolved, accessing
+   * this.resolved will synchronously flush all pending keyframe resolvers.
+   * This is a deoptimisation, but at its worst still batches read/writes.
+   */
+  get resolved() {
+    return !this._resolved && !this.hasAttemptedResolve && ys(), this._resolved;
+  }
+  /**
+   * A method to be called when the keyframes resolver completes. This method
+   * will check if its possible to run the animation and, if not, skip it.
+   * Otherwise, it will call initPlayback on the implementing class.
+   */
+  onKeyframesResolved(e, n) {
+    this.resolvedAt = N.now(), this.hasAttemptedResolve = !0;
+    const { name: s, type: i, velocity: r, delay: o, onComplete: l, onUpdate: a, isGenerator: u } = this.options;
+    if (!u && !Ns(e, s, i, r))
+      if (o)
+        this.options.duration = 0;
+      else {
+        a?.(de(e, this.options, n)), l?.(), this.resolveFinishedPromise();
+        return;
+      }
+    const h = this.initPlayback(e, n);
+    h !== !1 && (this._resolved = {
+      keyframes: e,
+      finalKeyframe: n,
+      ...h
+    }, this.onPostResolved());
+  }
+  onPostResolved() {
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(e, n) {
+    return this.currentFinishedPromise.then(e, n);
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((e) => {
+      this.resolveFinishedPromise = e;
+    });
+  }
+}
+function en(t, e) {
+  return e ? t * (1e3 / e) : 0;
+}
+const Bs = 5;
+function tn(t, e, n) {
+  const s = Math.max(e - Bs, 0);
+  return en(n - t(s), e - s);
+}
+const ge = 1e-3, Ls = 0.01, tt = 10, ks = 0.05, _s = 1;
+function Gs({ duration: t = 800, bounce: e = 0.25, velocity: n = 0, mass: s = 1 }) {
+  let i, r;
+  ue(t <= R(tt), "Spring duration must be 10 seconds or less");
+  let o = 1 - e;
+  o = Y(ks, _s, o), t = Y(Ls, tt, E(t)), o < 1 ? (i = (u) => {
+    const h = u * o, c = h * t, d = h - n, f = Ce(u, o), v = Math.exp(-c);
+    return ge - d / f * v;
+  }, r = (u) => {
+    const c = u * o * t, d = c * n + n, f = Math.pow(o, 2) * Math.pow(u, 2) * t, v = Math.exp(-c), T = Ce(Math.pow(u, 2), o);
+    return (-i(u) + ge > 0 ? -1 : 1) * ((d - f) * v) / T;
+  }) : (i = (u) => {
+    const h = Math.exp(-u * t), c = (u - n) * t + 1;
+    return -ge + h * c;
+  }, r = (u) => {
+    const h = Math.exp(-u * t), c = (n - u) * (t * t);
+    return h * c;
+  });
+  const l = 5 / t, a = $s(i, r, l);
+  if (t = R(t), isNaN(a))
+    return {
+      stiffness: 100,
+      damping: 10,
+      duration: t
+    };
+  {
+    const u = Math.pow(a, 2) * s;
+    return {
+      stiffness: u,
+      damping: o * 2 * Math.sqrt(s * u),
+      duration: t
+    };
+  }
+}
+const Us = 12;
+function $s(t, e, n) {
+  let s = n;
+  for (let i = 1; i < Us; i++)
+    s = s - t(s) / e(s);
+  return s;
+}
+function Ce(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const js = ["duration", "bounce"], Ws = ["stiffness", "damping", "mass"];
+function nt(t, e) {
+  return e.some((n) => t[n] !== void 0);
+}
+function zs(t) {
+  let e = {
+    velocity: 0,
+    stiffness: 100,
+    damping: 10,
+    mass: 1,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!nt(t, Ws) && nt(t, js)) {
+    const n = Gs(t);
+    e = {
+      ...e,
+      ...n,
+      mass: 1
+    }, e.isResolvedFromDuration = !0;
+  }
+  return e;
+}
+function nn({ keyframes: t, restDelta: e, restSpeed: n, ...s }) {
+  const i = t[0], r = t[t.length - 1], o = { done: !1, value: i }, { stiffness: l, damping: a, mass: u, duration: h, velocity: c, isResolvedFromDuration: d } = zs({
+    ...s,
+    velocity: -E(s.velocity || 0)
+  }), f = c || 0, v = a / (2 * Math.sqrt(l * u)), T = r - i, b = E(Math.sqrt(l / u)), m = Math.abs(T) < 5;
+  n || (n = m ? 0.01 : 2), e || (e = m ? 5e-3 : 0.5);
+  let y;
+  if (v < 1) {
+    const p = Ce(b, v);
+    y = (A) => {
+      const V = Math.exp(-v * b * A);
+      return r - V * ((f + v * b * T) / p * Math.sin(p * A) + T * Math.cos(p * A));
+    };
+  } else if (v === 1)
+    y = (p) => r - Math.exp(-b * p) * (T + (f + b * T) * p);
+  else {
+    const p = b * Math.sqrt(v * v - 1);
+    y = (A) => {
+      const V = Math.exp(-v * b * A), S = Math.min(p * A, 300);
+      return r - V * ((f + v * b * T) * Math.sinh(S) + p * T * Math.cosh(S)) / p;
+    };
+  }
+  return {
+    calculatedDuration: d && h || null,
+    next: (p) => {
+      const A = y(p);
+      if (d)
+        o.done = p >= h;
+      else {
+        let V = 0;
+        v < 1 && (V = p === 0 ? R(f) : tn(y, p, A));
+        const S = Math.abs(V) <= n, F = Math.abs(r - A) <= e;
+        o.done = S && F;
+      }
+      return o.value = o.done ? r : A, o;
+    }
+  };
+}
+function st({ keyframes: t, velocity: e = 0, power: n = 0.8, timeConstant: s = 325, bounceDamping: i = 10, bounceStiffness: r = 500, modifyTarget: o, min: l, max: a, restDelta: u = 0.5, restSpeed: h }) {
+  const c = t[0], d = {
+    done: !1,
+    value: c
+  }, f = (g) => l !== void 0 && g < l || a !== void 0 && g > a, v = (g) => l === void 0 ? a : a === void 0 || Math.abs(l - g) < Math.abs(a - g) ? l : a;
+  let T = n * e;
+  const b = c + T, m = o === void 0 ? b : o(b);
+  m !== b && (T = m - c);
+  const y = (g) => -T * Math.exp(-g / s), p = (g) => m + y(g), A = (g) => {
+    const C = y(g), M = p(g);
+    d.done = Math.abs(C) <= u, d.value = d.done ? m : M;
+  };
+  let V, S;
+  const F = (g) => {
+    f(d.value) && (V = g, S = nn({
+      keyframes: [d.value, v(d.value)],
+      velocity: tn(p, g, d.value),
+      // TODO: This should be passing * 1000
+      damping: i,
+      stiffness: r,
+      restDelta: u,
+      restSpeed: h
+    }));
+  };
+  return F(0), {
+    calculatedDuration: null,
+    next: (g) => {
+      let C = !1;
+      return !S && V === void 0 && (C = !0, A(g), F(g)), V !== void 0 && g >= V ? S.next(g - V) : (!C && A(g), d);
+    }
+  };
+}
+const sn = (t, e, n) => (((1 - 3 * n + 3 * e) * t + (3 * n - 6 * e)) * t + 3 * e) * t, Hs = 1e-7, qs = 12;
+function Ys(t, e, n, s, i) {
+  let r, o, l = 0;
+  do
+    o = e + (n - e) / 2, r = sn(o, s, i) - t, r > 0 ? n = o : e = o;
+  while (Math.abs(r) > Hs && ++l < qs);
+  return o;
+}
+function J(t, e, n, s) {
+  if (t === e && n === s)
+    return I;
+  const i = (r) => Ys(r, 0, 1, t, n);
+  return (r) => r === 0 || r === 1 ? r : sn(i(r), e, s);
+}
+const Xs = /* @__PURE__ */ J(0.42, 0, 1, 1), Zs = /* @__PURE__ */ J(0, 0, 0.58, 1), rn = /* @__PURE__ */ J(0.42, 0, 0.58, 1), Js = (t) => Array.isArray(t) && typeof t[0] != "number", on = (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, an = (t) => (e) => 1 - t(1 - e), _e = (t) => 1 - Math.sin(Math.acos(t)), Qs = an(_e), ei = on(_e), ln = /* @__PURE__ */ J(0.33, 1.53, 0.69, 0.99), Ge = /* @__PURE__ */ an(ln), ti = /* @__PURE__ */ on(Ge), ni = (t) => (t *= 2) < 1 ? 0.5 * Ge(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), it = {
+  linear: I,
+  easeIn: Xs,
+  easeInOut: rn,
+  easeOut: Zs,
+  circIn: _e,
+  circInOut: ei,
+  circOut: Qs,
+  backIn: Ge,
+  backInOut: ti,
+  backOut: ln,
+  anticipate: ni
+}, rt = (t) => {
+  if (Array.isArray(t)) {
+    q(t.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [e, n, s, i] = t;
+    return J(e, n, s, i);
+  } else if (typeof t == "string")
+    return q(it[t] !== void 0, `Invalid easing type '${t}'`), it[t];
+  return t;
+}, si = (t, e) => (n) => e(t(n)), K = (...t) => t.reduce(si), un = (t, e, n) => {
+  const s = e - t;
+  return s === 0 ? 1 : (n - t) / s;
+}, Q = (t, e, n) => t + (e - t) * n;
+function ve(t, e, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? t + (e - t) * 6 * n : n < 1 / 2 ? e : n < 2 / 3 ? t + (e - t) * (2 / 3 - n) * 6 : t;
+}
+function ii({ hue: t, saturation: e, lightness: n, alpha: s }) {
+  t /= 360, e /= 100, n /= 100;
+  let i = 0, r = 0, o = 0;
+  if (!e)
+    i = r = o = n;
+  else {
+    const l = n < 0.5 ? n * (1 + e) : n + e - n * e, a = 2 * n - l;
+    i = ve(a, l, t + 1 / 3), r = ve(a, l, t), o = ve(a, l, t - 1 / 3);
+  }
+  return {
+    red: Math.round(i * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(o * 255),
+    alpha: s
+  };
+}
+function ie(t, e) {
+  return (n) => n > 0 ? e : t;
+}
+const ye = (t, e, n) => {
+  const s = t * t, i = n * (e * e - s) + s;
+  return i < 0 ? 0 : Math.sqrt(i);
+}, ri = [xe, L, U], oi = (t) => ri.find((e) => e.test(t));
+function ot(t) {
+  const e = oi(t);
+  if (ue(!!e, `'${t}' is not an animatable color. Use the equivalent color code instead.`), !e)
+    return !1;
+  let n = e.parse(t);
+  return e === U && (n = ii(n)), n;
+}
+const at = (t, e) => {
+  const n = ot(t), s = ot(e);
+  if (!n || !s)
+    return ie(t, e);
+  const i = { ...n };
+  return (r) => (i.red = ye(n.red, s.red, r), i.green = ye(n.green, s.green, r), i.blue = ye(n.blue, s.blue, r), i.alpha = Q(n.alpha, s.alpha, r), L.transform(i));
+}, Me = /* @__PURE__ */ new Set(["none", "hidden"]);
+function ai(t, e) {
+  return Me.has(t) ? (n) => n <= 0 ? t : e : (n) => n >= 1 ? e : t;
+}
+function li(t, e) {
+  return (n) => Q(t, e, n);
+}
+function Ue(t) {
+  return typeof t == "number" ? li : typeof t == "string" ? Ie(t) ? ie : w.test(t) ? at : hi : Array.isArray(t) ? cn : typeof t == "object" ? w.test(t) ? at : ui : ie;
+}
+function cn(t, e) {
+  const n = [...t], s = n.length, i = t.map((r, o) => Ue(r)(r, e[o]));
+  return (r) => {
+    for (let o = 0; o < s; o++)
+      n[o] = i[o](r);
+    return n;
+  };
+}
+function ui(t, e) {
+  const n = { ...t, ...e }, s = {};
+  for (const i in n)
+    t[i] !== void 0 && e[i] !== void 0 && (s[i] = Ue(t[i])(t[i], e[i]));
+  return (i) => {
+    for (const r in s)
+      n[r] = s[r](i);
+    return n;
+  };
+}
+function ci(t, e) {
+  var n;
+  const s = [], i = { color: 0, var: 0, number: 0 };
+  for (let r = 0; r < e.values.length; r++) {
+    const o = e.types[r], l = t.indexes[o][i[o]], a = (n = t.values[l]) !== null && n !== void 0 ? n : 0;
+    s[r] = a, i[o]++;
+  }
+  return s;
+}
+const hi = (t, e) => {
+  const n = j.createTransformer(e), s = X(t), i = X(e);
+  return s.indexes.var.length === i.indexes.var.length && s.indexes.color.length === i.indexes.color.length && s.indexes.number.length >= i.indexes.number.length ? Me.has(t) && !i.values.length || Me.has(e) && !s.values.length ? ai(t, e) : K(cn(ci(s, i), i.values), n) : (ue(!0, `Complex values '${t}' and '${e}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`), ie(t, e));
+};
+function hn(t, e, n) {
+  return typeof t == "number" && typeof e == "number" && typeof n == "number" ? Q(t, e, n) : Ue(t)(t, e);
+}
+function di(t, e, n) {
+  const s = [], i = n || hn, r = t.length - 1;
+  for (let o = 0; o < r; o++) {
+    let l = i(t[o], t[o + 1]);
+    if (e) {
+      const a = Array.isArray(e) ? e[o] || I : e;
+      l = K(a, l);
+    }
+    s.push(l);
+  }
+  return s;
+}
+function fi(t, e, { clamp: n = !0, ease: s, mixer: i } = {}) {
+  const r = t.length;
+  if (q(r === e.length, "Both input and output ranges must be the same length"), r === 1)
+    return () => e[0];
+  if (r === 2 && t[0] === t[1])
+    return () => e[1];
+  t[0] > t[r - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const o = di(e, s, i), l = o.length, a = (u) => {
+    let h = 0;
+    if (l > 1)
+      for (; h < t.length - 2 && !(u < t[h + 1]); h++)
+        ;
+    const c = un(t[h], t[h + 1], u);
+    return o[h](c);
+  };
+  return n ? (u) => a(Y(t[0], t[r - 1], u)) : a;
+}
+function pi(t, e) {
+  const n = t[t.length - 1];
+  for (let s = 1; s <= e; s++) {
+    const i = un(0, e, s);
+    t.push(Q(n, 1, i));
+  }
+}
+function mi(t) {
+  const e = [0];
+  return pi(e, t.length - 1), e;
+}
+function gi(t, e) {
+  return t.map((n) => n * e);
+}
+function vi(t, e) {
+  return t.map(() => e || rn).splice(0, t.length - 1);
+}
+function re({ duration: t = 300, keyframes: e, times: n, ease: s = "easeInOut" }) {
+  const i = Js(s) ? s.map(rt) : rt(s), r = {
+    done: !1,
+    value: e[0]
+  }, o = gi(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    n && n.length === e.length ? n : mi(e),
+    t
+  ), l = fi(o, e, {
+    ease: Array.isArray(i) ? i : vi(e, i)
+  });
+  return {
+    calculatedDuration: t,
+    next: (a) => (r.value = l(a), r.done = a >= t, r)
+  };
+}
+const lt = 2e4;
+function yi(t) {
+  let e = 0;
+  const n = 50;
+  let s = t.next(e);
+  for (; !s.done && e < lt; )
+    e += n, s = t.next(e);
+  return e >= lt ? 1 / 0 : e;
+}
+const bi = (t) => {
+  const e = ({ timestamp: n }) => t(n);
+  return {
+    start: () => P.update(e, !0),
+    stop: () => se(e),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => ne.isProcessing ? ne.timestamp : N.now()
+  };
+}, Ti = {
+  decay: st,
+  inertia: st,
+  tween: re,
+  keyframes: re,
+  spring: nn
+}, Vi = (t) => t / 100;
+class $e extends Qt {
+  constructor(e) {
+    super(e), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
+      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop: a } = this.options;
+      a && a();
+    };
+    const { name: n, motionValue: s, element: i, keyframes: r } = this.options, o = i?.KeyframeResolver || Be, l = (a, u) => this.onKeyframesResolved(a, u);
+    this.resolver = new o(r, l, n, s, i), this.resolver.scheduleResolve();
+  }
+  initPlayback(e) {
+    const { type: n = "keyframes", repeat: s = 0, repeatDelay: i = 0, repeatType: r, velocity: o = 0 } = this.options, l = Ti[n] || re;
+    let a, u;
+    l !== re && typeof e[0] != "number" && (ce.env.NODE_ENV !== "production" && q(e.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${e}`), a = K(Vi, hn(e[0], e[1])), e = [0, 100]);
+    const h = l({ ...this.options, keyframes: e });
+    r === "mirror" && (u = l({
+      ...this.options,
+      keyframes: [...e].reverse(),
+      velocity: -o
+    })), h.calculatedDuration === null && (h.calculatedDuration = yi(h));
+    const { calculatedDuration: c } = h, d = c + i, f = d * (s + 1) - i;
+    return {
+      generator: h,
+      mirroredGenerator: u,
+      mapPercentToKeyframes: a,
+      calculatedDuration: c,
+      resolvedDuration: d,
+      totalDuration: f
+    };
+  }
+  onPostResolved() {
+    const { autoplay: e = !0 } = this.options;
+    this.play(), this.pendingPlayState === "paused" || !e ? this.pause() : this.state = this.pendingPlayState;
+  }
+  tick(e, n = !1) {
+    const { resolved: s } = this;
+    if (!s) {
+      const { keyframes: g } = this.options;
+      return { done: !0, value: g[g.length - 1] };
+    }
+    const { finalKeyframe: i, generator: r, mirroredGenerator: o, mapPercentToKeyframes: l, keyframes: a, calculatedDuration: u, totalDuration: h, resolvedDuration: c } = s;
+    if (this.startTime === null)
+      return r.next(0);
+    const { delay: d, repeat: f, repeatType: v, repeatDelay: T, onUpdate: b } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - h / this.speed, this.startTime)), n ? this.currentTime = e : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(e - this.startTime) * this.speed;
+    const m = this.currentTime - d * (this.speed >= 0 ? 1 : -1), y = this.speed >= 0 ? m < 0 : m > h;
+    this.currentTime = Math.max(m, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = h);
+    let p = this.currentTime, A = r;
+    if (f) {
+      const g = Math.min(this.currentTime, h) / c;
+      let C = Math.floor(g), M = g % 1;
+      !M && g >= 1 && (M = 1), M === 1 && C--, C = Math.min(C, f + 1), !!(C % 2) && (v === "reverse" ? (M = 1 - M, T && (M -= T / c)) : v === "mirror" && (A = o)), p = Y(0, 1, M) * c;
+    }
+    const V = y ? { done: !1, value: a[0] } : A.next(p);
+    l && (V.value = l(V.value));
+    let { done: S } = V;
+    !y && u !== null && (S = this.speed >= 0 ? this.currentTime >= h : this.currentTime <= 0);
+    const F = this.holdTime === null && (this.state === "finished" || this.state === "running" && S);
+    return F && i !== void 0 && (V.value = de(a, this.options, i)), b && b(V.value), F && this.finish(), V;
+  }
+  get duration() {
+    const { resolved: e } = this;
+    return e ? E(e.calculatedDuration) : 0;
+  }
+  get time() {
+    return E(this.currentTime);
+  }
+  set time(e) {
+    e = R(e), this.currentTime = e, this.holdTime !== null || this.speed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.speed);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(e) {
+    const n = this.playbackSpeed !== e;
+    this.playbackSpeed = e, n && (this.time = E(this.currentTime));
+  }
+  play() {
+    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver: e = bi, onPlay: n, startTime: s } = this.options;
+    this.driver || (this.driver = e((r) => this.tick(r))), n && n();
+    const i = this.driver.now();
+    this.holdTime !== null ? this.startTime = i - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = i) : this.startTime = s ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    var e;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused", this.holdTime = (e = this.currentTime) !== null && e !== void 0 ? e : 0;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.teardown(), this.state = "finished";
+    const { onComplete: e } = this.options;
+    e && e();
+  }
+  cancel() {
+    this.cancelTime !== null && this.tick(this.cancelTime), this.teardown(), this.updateFinishedPromise();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.resolveFinishedPromise(), this.updateFinishedPromise(), this.startTime = this.cancelTime = null, this.resolver.cancel();
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(e) {
+    return this.startTime = 0, this.tick(e, !0);
+  }
+}
+const dn = (t) => Array.isArray(t) && typeof t[0] == "number";
+function fn(t) {
+  return !!(!t || typeof t == "string" && t in je || dn(t) || Array.isArray(t) && t.every(fn));
+}
+const z = ([t, e, n, s]) => `cubic-bezier(${t}, ${e}, ${n}, ${s})`, je = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ z([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ z([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ z([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ z([0.33, 1.53, 0.69, 0.99])
+};
+function Ai(t) {
+  return pn(t) || je.easeOut;
+}
+function pn(t) {
+  if (t)
+    return dn(t) ? z(t) : Array.isArray(t) ? t.map(Ai) : je[t];
+}
+function Si(t, e, n, { delay: s = 0, duration: i = 300, repeat: r = 0, repeatType: o = "loop", ease: l, times: a } = {}) {
+  const u = { [e]: n };
+  a && (u.offset = a);
+  const h = pn(l);
+  return Array.isArray(h) && (u.easing = h), t.animate(u, {
+    delay: s,
+    duration: i,
+    easing: Array.isArray(h) ? "linear" : h,
+    fill: "both",
+    iterations: r + 1,
+    direction: o === "reverse" ? "alternate" : "normal"
+  });
+}
+const wi = /* @__PURE__ */ Jt(() => Object.hasOwnProperty.call(Element.prototype, "animate")), oe = 10, xi = 2e4;
+function Pi(t) {
+  return t.type === "spring" || !fn(t.ease);
+}
+function Ci(t, e) {
+  const n = new $e({
+    ...e,
+    keyframes: t,
+    repeat: 0,
+    delay: 0,
+    isGenerator: !0
+  });
+  let s = { done: !1, value: t[0] };
+  const i = [];
+  let r = 0;
+  for (; !s.done && r < xi; )
+    s = n.sample(r), i.push(s.value), r += oe;
+  return {
+    times: void 0,
+    keyframes: i,
+    duration: r - oe,
+    ease: "linear"
+  };
+}
+class ut extends Qt {
+  constructor(e) {
+    super(e);
+    const { name: n, motionValue: s, element: i, keyframes: r } = this.options;
+    this.resolver = new Zt(r, (o, l) => this.onKeyframesResolved(o, l), n, s, i), this.resolver.scheduleResolve();
+  }
+  initPlayback(e, n) {
+    var s;
+    let { duration: i = 300, times: r, ease: o, type: l, motionValue: a, name: u, startTime: h } = this.options;
+    if (!(!((s = a.owner) === null || s === void 0) && s.current))
+      return !1;
+    if (Pi(this.options)) {
+      const { onComplete: d, onUpdate: f, motionValue: v, element: T, ...b } = this.options, m = Ci(e, b);
+      e = m.keyframes, e.length === 1 && (e[1] = e[0]), i = m.duration, r = m.times, o = m.ease, l = "keyframes";
+    }
+    const c = Si(a.owner.current, u, e, { ...this.options, duration: i, times: r, ease: o });
+    return c.startTime = h ?? this.calcStartTime(), this.pendingTimeline ? (c.timeline = this.pendingTimeline, this.pendingTimeline = void 0) : c.onfinish = () => {
+      const { onComplete: d } = this.options;
+      a.set(de(e, this.options, n)), d && d(), this.cancel(), this.resolveFinishedPromise();
+    }, {
+      animation: c,
+      duration: i,
+      times: r,
+      type: l,
+      ease: o,
+      keyframes: e
+    };
+  }
+  get duration() {
+    const { resolved: e } = this;
+    if (!e)
+      return 0;
+    const { duration: n } = e;
+    return E(n);
+  }
+  get time() {
+    const { resolved: e } = this;
+    if (!e)
+      return 0;
+    const { animation: n } = e;
+    return E(n.currentTime || 0);
+  }
+  set time(e) {
+    const { resolved: n } = this;
+    if (!n)
+      return;
+    const { animation: s } = n;
+    s.currentTime = R(e);
+  }
+  get speed() {
+    const { resolved: e } = this;
+    if (!e)
+      return 1;
+    const { animation: n } = e;
+    return n.playbackRate;
+  }
+  set speed(e) {
+    const { resolved: n } = this;
+    if (!n)
+      return;
+    const { animation: s } = n;
+    s.playbackRate = e;
+  }
+  get state() {
+    const { resolved: e } = this;
+    if (!e)
+      return "idle";
+    const { animation: n } = e;
+    return n.playState;
+  }
+  get startTime() {
+    const { resolved: e } = this;
+    if (!e)
+      return null;
+    const { animation: n } = e;
+    return n.startTime;
+  }
+  /**
+   * Replace the default DocumentTimeline with another AnimationTimeline.
+   * Currently used for scroll animations.
+   */
+  attachTimeline(e) {
+    if (!this._resolved)
+      this.pendingTimeline = e;
+    else {
+      const { resolved: n } = this;
+      if (!n)
+        return I;
+      const { animation: s } = n;
+      s.timeline = e, s.onfinish = null;
+    }
+    return I;
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { resolved: e } = this;
+    if (!e)
+      return;
+    const { animation: n } = e;
+    n.playState === "finished" && this.updateFinishedPromise(), n.play();
+  }
+  pause() {
+    const { resolved: e } = this;
+    if (!e)
+      return;
+    const { animation: n } = e;
+    n.pause();
+  }
+  stop() {
+    if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+      return;
+    this.resolveFinishedPromise(), this.updateFinishedPromise();
+    const { resolved: e } = this;
+    if (!e)
+      return;
+    const { animation: n, keyframes: s, duration: i, type: r, ease: o, times: l } = e;
+    if (n.playState === "idle" || n.playState === "finished")
+      return;
+    if (this.time) {
+      const { motionValue: u, onUpdate: h, onComplete: c, element: d, ...f } = this.options, v = new $e({
+        ...f,
+        keyframes: s,
+        duration: i,
+        type: r,
+        ease: o,
+        times: l,
+        isGenerator: !0
+      }), T = R(this.time);
+      u.setWithVelocity(v.sample(T - oe).value, v.sample(T).value, oe);
+    }
+    const { onStop: a } = this.options;
+    a && a(), this.cancel();
+  }
+  complete() {
+    const { resolved: e } = this;
+    e && e.animation.finish();
+  }
+  cancel() {
+    const { resolved: e } = this;
+    e && e.animation.cancel();
+  }
+  static supports(e) {
+    const { motionValue: n, name: s, repeatDelay: i, repeatType: r, damping: o, type: l } = e;
+    return wi() && s && Kn.has(s) && n && n.owner && n.owner.current instanceof HTMLElement && /**
+     * If we're outputting values to onUpdate then we can't use WAAPI as there's
+     * no way to read the value from WAAPI every frame.
+     */
+    !n.owner.getProps().onUpdate && !i && r !== "mirror" && o !== 0 && l !== "inertia";
+  }
+}
+function Mi(t, e) {
+  let n;
+  const s = () => {
+    const { currentTime: i } = e, o = (i === null ? 0 : i.value) / 100;
+    n !== o && t(o), n = o;
+  };
+  return P.update(s, !0), () => se(s);
+}
+const Fi = Jt(() => window.ScrollTimeline !== void 0);
+class Di {
+  constructor(e) {
+    this.stop = () => this.runAll("stop"), this.animations = e.filter(Boolean);
+  }
+  then(e, n) {
+    return Promise.all(this.animations).then(e).catch(n);
+  }
+  /**
+   * TODO: Filter out cancelled or stopped animations before returning
+   */
+  getAll(e) {
+    return this.animations[0][e];
+  }
+  setAll(e, n) {
+    for (let s = 0; s < this.animations.length; s++)
+      this.animations[s][e] = n;
+  }
+  attachTimeline(e) {
+    const n = this.animations.map((s) => {
+      if (Fi() && s.attachTimeline)
+        s.attachTimeline(e);
+      else
+        return s.pause(), Mi((i) => {
+          s.time = s.duration * i;
+        }, e);
+    });
+    return () => {
+      n.forEach((s, i) => {
+        s && s(), this.animations[i].stop();
+      });
+    };
+  }
+  get time() {
+    return this.getAll("time");
+  }
+  set time(e) {
+    this.setAll("time", e);
+  }
+  get speed() {
+    return this.getAll("speed");
+  }
+  set speed(e) {
+    this.setAll("speed", e);
+  }
+  get startTime() {
+    return this.getAll("startTime");
+  }
+  get duration() {
+    let e = 0;
+    for (let n = 0; n < this.animations.length; n++)
+      e = Math.max(e, this.animations[n].duration);
+    return e;
+  }
+  runAll(e) {
+    this.animations.forEach((n) => n[e]());
+  }
+  play() {
+    this.runAll("play");
+  }
+  pause() {
+    this.runAll("pause");
+  }
+  cancel() {
+    this.runAll("cancel");
+  }
+  complete() {
+    this.runAll("complete");
+  }
+}
+const Ri = (t, e, n, s = {}, i, r, o) => (l) => {
+  const a = Bt(s, t) || {}, u = a.delay || s.delay || 0;
+  let { elapsed: h = 0 } = s;
+  h = h - R(u);
+  let c = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...a,
+    delay: -h,
+    onUpdate: (f) => {
+      e.set(f), a.onUpdate && a.onUpdate(f);
+    },
+    onComplete: () => {
+      l(), a.onComplete && a.onComplete(), o && o();
+    },
+    onStop: o,
+    name: t,
+    motionValue: e,
+    element: r ? void 0 : i
+  };
+  as(a) || (c = {
+    ...c,
+    ...os(t, c)
+  }), c.duration && (c.duration = R(c.duration)), c.repeatDelay && (c.repeatDelay = R(c.repeatDelay)), c.from !== void 0 && (c.keyframes[0] = c.from);
+  let d = !1;
+  if ((c.type === !1 || c.duration === 0 && !c.repeatDelay) && (c.duration = 0, c.delay === 0 && (d = !0)), Dt.skipAnimations && (d = !0, c.duration = 0, c.delay = 0), d && !r && e.get() !== void 0) {
+    const f = de(c.keyframes, a);
+    if (f !== void 0)
+      return P.update(() => {
+        c.onUpdate(f), c.onComplete();
+      }), new Di([]);
+  }
+  return !r && ut.supports(c) ? new ut(c) : new $e(c);
+};
+class mn {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(e) {
+    return Bn(this.subscriptions, e), () => Rt(this.subscriptions, e);
+  }
+  notify(e, n, s) {
+    const i = this.subscriptions.length;
+    if (i)
+      if (i === 1)
+        this.subscriptions[0](e, n, s);
+      else
+        for (let r = 0; r < i; r++) {
+          const o = this.subscriptions[r];
+          o && o(e, n, s);
+        }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}
+const ct = 30, Oi = (t) => !isNaN(parseFloat(t));
+class gn {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   *
+   * @internal
+   */
+  constructor(e, n = {}) {
+    this.version = "11.5.6", this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s, i = !0) => {
+      const r = N.now();
+      this.updatedAt !== r && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && this.events.change && this.events.change.notify(this.current), i && this.events.renderRequest && this.events.renderRequest.notify(this.current);
+    }, this.hasAnimated = !1, this.setCurrent(e), this.owner = n.owner;
+  }
+  setCurrent(e) {
+    this.current = e, this.updatedAt = N.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = Oi(this.current));
+  }
+  setPrevFrameValue(e = this.current) {
+    this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(e) {
+    return ce.env.NODE_ENV !== "production" && Ke(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", e);
+  }
+  on(e, n) {
+    this.events[e] || (this.events[e] = new mn());
+    const s = this.events[e].add(n);
+    return e === "change" ? () => {
+      s(), P.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : s;
+  }
+  clearListeners() {
+    for (const e in this.events)
+      this.events[e].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   *
+   * @internal
+   */
+  attach(e, n) {
+    this.passiveEffect = e, this.stopPassiveEffect = n;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(e, n = !0) {
+    !n || !this.passiveEffect ? this.updateAndNotify(e, n) : this.passiveEffect(e, this.updateAndNotify);
+  }
+  setWithVelocity(e, n, s) {
+    this.set(n), this.prev = void 0, this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt - s;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(e, n = !0) {
+    this.updateAndNotify(e), this.prev = e, this.prevUpdatedAt = this.prevFrameValue = void 0, n && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const e = N.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > ct)
+      return 0;
+    const n = Math.min(this.updatedAt - this.prevUpdatedAt, ct);
+    return en(parseFloat(this.current) - parseFloat(this.prevFrameValue), n);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   *
+   * @internal
+   */
+  start(e) {
+    return this.stop(), new Promise((n) => {
+      this.hasAnimated = !0, this.animation = e(n), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function ae(t, e) {
+  return new gn(t, e);
+}
+function Ii(t, e, n) {
+  t.hasValue(e) ? t.getValue(e).set(n) : t.addValue(e, ae(n));
+}
+function Ei(t, e) {
+  const n = he(t, e);
+  let { transitionEnd: s = {}, transition: i = {}, ...r } = n || {};
+  r = { ...r, ...s };
+  for (const o in r) {
+    const l = Ln(r[o]);
+    Ii(t, o, l);
+  }
+}
+function Ni(t) {
+  return t.props[kn];
+}
+class Ki extends gn {
+  constructor() {
+    super(...arguments), this.output = [], this.counts = /* @__PURE__ */ new Map();
+  }
+  add(e) {
+    const n = _n(e);
+    if (!n)
+      return;
+    const s = this.counts.get(n) || 0;
+    this.counts.set(n, s + 1), s === 0 && (this.output.push(n), this.update());
+    let i = !1;
+    return () => {
+      if (i)
+        return;
+      i = !0;
+      const r = this.counts.get(n) - 1;
+      this.counts.set(n, r), r === 0 && (Rt(this.output, n), this.update());
+    };
+  }
+  update() {
+    this.set(this.output.length ? this.output.join(", ") : "auto");
+  }
+}
+function Bi(t) {
+  return !!(O(t) && t.add);
+}
+function Li(t, e) {
+  var n;
+  if (!t.applyWillChange)
+    return;
+  let s = t.getValue("willChange");
+  if (!s && !(!((n = t.props.style) === null || n === void 0) && n.willChange) && (s = new Ki("auto"), t.addValue("willChange", s)), Bi(s))
+    return s.add(e);
+}
+function ki({ protectedKeys: t, needsAnimating: e }, n) {
+  const s = t.hasOwnProperty(n) && e[n] !== !0;
+  return e[n] = !1, s;
+}
+function vn(t, e, { delay: n = 0, transitionOverride: s, type: i } = {}) {
+  var r;
+  let { transition: o = t.getDefaultTransition(), transitionEnd: l, ...a } = e;
+  s && (o = s);
+  const u = [], h = i && t.animationState && t.animationState.getState()[i];
+  for (const c in a) {
+    const d = t.getValue(c, (r = t.latestValues[c]) !== null && r !== void 0 ? r : null), f = a[c];
+    if (f === void 0 || h && ki(h, c))
+      continue;
+    const v = {
+      delay: n,
+      ...Bt(o || {}, c)
+    };
+    let T = !1;
+    if (window.MotionHandoffAnimation) {
+      const m = Ni(t);
+      if (m) {
+        const y = window.MotionHandoffAnimation(m, c, P);
+        y !== null && (v.startTime = y, T = !0);
+      }
+    }
+    d.start(Ri(c, d, f, t.shouldReduceMotion && Z.has(c) ? { type: !1 } : v, t, T, Li(t, c)));
+    const b = d.animation;
+    b && u.push(b);
+  }
+  return l && Promise.all(u).then(() => {
+    P.update(() => {
+      l && Ei(t, l);
+    });
+  }), u;
+}
+function Fe(t, e, n = {}) {
+  var s;
+  const i = he(t, e, n.type === "exit" ? (s = t.presenceContext) === null || s === void 0 ? void 0 : s.custom : void 0);
+  let { transition: r = t.getDefaultTransition() || {} } = i || {};
+  n.transitionOverride && (r = n.transitionOverride);
+  const o = i ? () => Promise.all(vn(t, i, n)) : () => Promise.resolve(), l = t.variantChildren && t.variantChildren.size ? (u = 0) => {
+    const { delayChildren: h = 0, staggerChildren: c, staggerDirection: d } = r;
+    return _i(t, e, h + u, c, d, n);
+  } : () => Promise.resolve(), { when: a } = r;
+  if (a) {
+    const [u, h] = a === "beforeChildren" ? [o, l] : [l, o];
+    return u().then(() => h());
+  } else
+    return Promise.all([o(), l(n.delay)]);
+}
+function _i(t, e, n = 0, s = 0, i = 1, r) {
+  const o = [], l = (t.variantChildren.size - 1) * s, a = i === 1 ? (u = 0) => u * s : (u = 0) => l - u * s;
+  return Array.from(t.variantChildren).sort(Gi).forEach((u, h) => {
+    u.notify("AnimationStart", e), o.push(Fe(u, e, {
+      ...r,
+      delay: n + a(h)
+    }).then(() => u.notify("AnimationComplete", e)));
+  }), Promise.all(o);
+}
+function Gi(t, e) {
+  return t.sortNodePosition(e);
+}
+function Ui(t, e, n = {}) {
+  t.notify("AnimationStart", e);
+  let s;
+  if (Array.isArray(e)) {
+    const i = e.map((r) => Fe(t, r, n));
+    s = Promise.all(i);
+  } else if (typeof e == "string")
+    s = Fe(t, e, n);
+  else {
+    const i = typeof e == "function" ? he(t, e, n.custom) : e;
+    s = Promise.all(vn(t, i, n));
+  }
+  return s.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+const $i = It.length;
+function yn(t) {
+  if (!t)
+    return;
+  if (!t.isControllingVariants) {
+    const n = t.parent ? yn(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (n.initial = t.props.initial), n;
+  }
+  const e = {};
+  for (let n = 0; n < $i; n++) {
+    const s = It[n], i = t.props[s];
+    (Ot(i) || i === !1) && (e[s] = i);
+  }
+  return e;
+}
+const ji = [...Nt].reverse(), Wi = Nt.length;
+function zi(t) {
+  return (e) => Promise.all(e.map(({ animation: n, options: s }) => Ui(t, n, s)));
+}
+function Hi(t) {
+  let e = zi(t), n = ht(), s = !0;
+  const i = (a) => (u, h) => {
+    var c;
+    const d = he(t, h, a === "exit" ? (c = t.presenceContext) === null || c === void 0 ? void 0 : c.custom : void 0);
+    if (d) {
+      const { transition: f, transitionEnd: v, ...T } = d;
+      u = { ...u, ...T, ...v };
+    }
+    return u;
+  };
+  function r(a) {
+    e = a(t);
+  }
+  function o(a) {
+    const { props: u } = t, h = yn(t.parent) || {}, c = [], d = /* @__PURE__ */ new Set();
+    let f = {}, v = 1 / 0;
+    for (let b = 0; b < Wi; b++) {
+      const m = ji[b], y = n[m], p = u[m] !== void 0 ? u[m] : h[m], A = Ot(p), V = m === a ? y.isActive : null;
+      V === !1 && (v = b);
+      let S = p === h[m] && p !== u[m] && A;
+      if (S && s && t.manuallyAnimateOnMount && (S = !1), y.protectedKeys = { ...f }, // If it isn't active and hasn't *just* been set as inactive
+      !y.isActive && V === null || // If we didn't and don't have any defined prop for this animation type
+      !p && !y.prevProp || // Or if the prop doesn't define an animation
+      Et(p) || typeof p == "boolean")
+        continue;
+      const F = qi(y.prevProp, p);
+      let g = F || // If we're making this variant active, we want to always make it active
+      m === a && y.isActive && !S && A || // If we removed a higher-priority variant (i is in reverse order)
+      b > v && A, C = !1;
+      const M = Array.isArray(p) ? p : [p];
+      let G = M.reduce(i(m), {});
+      V === !1 && (G = {});
+      const { prevResolvedValues: We = {} } = y, Cn = {
+        ...We,
+        ...G
+      }, ze = (x) => {
+        g = !0, d.has(x) && (C = !0, d.delete(x)), y.needsAnimating[x] = !0;
+        const D = t.getValue(x);
+        D && (D.liveStyle = !1);
+      };
+      for (const x in Cn) {
+        const D = G[x], fe = We[x];
+        if (f.hasOwnProperty(x))
+          continue;
+        let pe = !1;
+        He(D) && He(fe) ? pe = !Kt(D, fe) : pe = D !== fe, pe ? D != null ? ze(x) : d.add(x) : D !== void 0 && d.has(x) ? ze(x) : y.protectedKeys[x] = !0;
+      }
+      y.prevProp = p, y.prevResolvedValues = G, y.isActive && (f = { ...f, ...G }), s && t.blockInitialAnimation && (g = !1), g && (!(S && F) || C) && c.push(...M.map((x) => ({
+        animation: x,
+        options: { type: m }
+      })));
+    }
+    if (d.size) {
+      const b = {};
+      d.forEach((m) => {
+        const y = t.getBaseTarget(m), p = t.getValue(m);
+        p && (p.liveStyle = !0), b[m] = y ?? null;
+      }), c.push({ animation: b });
+    }
+    let T = !!c.length;
+    return s && (u.initial === !1 || u.initial === u.animate) && !t.manuallyAnimateOnMount && (T = !1), s = !1, T ? e(c) : Promise.resolve();
+  }
+  function l(a, u) {
+    var h;
+    if (n[a].isActive === u)
+      return Promise.resolve();
+    (h = t.variantChildren) === null || h === void 0 || h.forEach((d) => {
+      var f;
+      return (f = d.animationState) === null || f === void 0 ? void 0 : f.setActive(a, u);
+    }), n[a].isActive = u;
+    const c = o(a);
+    for (const d in n)
+      n[d].protectedKeys = {};
+    return c;
+  }
+  return {
+    animateChanges: o,
+    setActive: l,
+    setAnimateFunction: r,
+    getState: () => n,
+    reset: () => {
+      n = ht(), s = !0;
+    }
+  };
+}
+function qi(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !Kt(e, t) : !1;
+}
+function B(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function ht() {
+  return {
+    animate: B(!0),
+    whileInView: B(),
+    whileHover: B(),
+    whileTap: B(),
+    whileDrag: B(),
+    whileFocus: B(),
+    exit: B()
+  };
+}
+class W {
+  constructor(e) {
+    this.isMounted = !1, this.node = e;
+  }
+  update() {
+  }
+}
+class Yi extends W {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(e) {
+    super(e), e.animationState || (e.animationState = Hi(e));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: e } = this.node.getProps();
+    Et(e) && (this.unmountControls = e.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: e } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    e !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    var e;
+    this.node.animationState.reset(), (e = this.unmountControls) === null || e === void 0 || e.call(this);
+  }
+}
+let Xi = 0;
+class Zi extends W {
+  constructor() {
+    super(...arguments), this.id = Xi++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: e, onExitComplete: n } = this.node.presenceContext, { isPresent: s } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || e === s)
+      return;
+    const i = this.node.animationState.setActive("exit", !e);
+    n && !e && i.then(() => n(this.id));
+  }
+  mount() {
+    const { register: e } = this.node.presenceContext || {};
+    e && (this.unmount = e(this.id));
+  }
+  unmount() {
+  }
+}
+const Ji = {
+  animation: {
+    Feature: Yi
+  },
+  exit: {
+    Feature: Zi
+  }
+}, Qi = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1;
+function bn(t, e = "page") {
+  return {
+    point: {
+      x: t[`${e}X`],
+      y: t[`${e}Y`]
+    }
+  };
+}
+const er = (t) => (e) => Qi(e) && t(e, bn(e));
+function k(t, e, n, s = { passive: !0 }) {
+  return t.addEventListener(e, n, s), () => t.removeEventListener(e, n);
+}
+function te(t, e, n, s) {
+  return k(t, e, er(n), s);
+}
+function Tn(t) {
+  let e = null;
+  return () => {
+    const n = () => {
+      e = null;
+    };
+    return e === null ? (e = t, n) : !1;
+  };
+}
+const dt = Tn("dragHorizontal"), ft = Tn("dragVertical");
+function tr(t) {
+  let e = !1;
+  if (t === "y")
+    e = ft();
+  else if (t === "x")
+    e = dt();
+  else {
+    const n = dt(), s = ft();
+    n && s ? e = () => {
+      n(), s();
+    } : (n && n(), s && s());
+  }
+  return e;
+}
+function Vn() {
+  const t = tr(!0);
+  return t ? (t(), !1) : !0;
+}
+const pt = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), Or = () => ({
+  x: pt(),
+  y: pt()
+}), mt = () => ({ min: 0, max: 0 }), An = () => ({
+  x: mt(),
+  y: mt()
+});
+function nr({ top: t, left: e, right: n, bottom: s }) {
+  return {
+    x: { min: e, max: n },
+    y: { min: t, max: s }
+  };
+}
+function Ir({ x: t, y: e }) {
+  return { top: e.min, right: t.max, bottom: e.max, left: t.min };
+}
+function sr(t, e) {
+  if (!e)
+    return t;
+  const n = e({ x: t.left, y: t.top }), s = e({ x: t.right, y: t.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: s.y,
+    right: s.x
+  };
+}
+function be(t) {
+  return t === void 0 || t === 1;
+}
+function ir({ scale: t, scaleX: e, scaleY: n }) {
+  return !be(t) || !be(e) || !be(n);
+}
+function rr(t) {
+  return ir(t) || or(t) || t.z || t.rotate || t.rotateX || t.rotateY || t.skewX || t.skewY;
+}
+function or(t) {
+  return gt(t.x) || gt(t.y);
+}
+function gt(t) {
+  return t && t !== "0%";
+}
+function vt(t, e, n) {
+  const s = t - n, i = e * s;
+  return n + i;
+}
+function yt(t, e, n, s, i) {
+  return i !== void 0 && (t = vt(t, i, s)), vt(t, n, s) + e;
+}
+function De(t, e = 0, n = 1, s, i) {
+  t.min = yt(t.min, e, n, s, i), t.max = yt(t.max, e, n, s, i);
+}
+function ar(t, { x: e, y: n }) {
+  De(t.x, e.translate, e.scale, e.originPoint), De(t.y, n.translate, n.scale, n.originPoint);
+}
+const bt = 0.999999999999, Tt = 1.0000000000001;
+function Er(t, e, n, s = !1) {
+  const i = n.length;
+  if (!i)
+    return;
+  e.x = e.y = 1;
+  let r, o;
+  for (let l = 0; l < i; l++) {
+    r = n[l], o = r.projectionDelta;
+    const { visualElement: a } = r.options;
+    a && a.props.style && a.props.style.display === "contents" || (s && r.options.layoutScroll && r.scroll && r !== r.root && St(t, {
+      x: -r.scroll.offset.x,
+      y: -r.scroll.offset.y
+    }), o && (e.x *= o.x.scale, e.y *= o.y.scale, ar(t, o)), s && rr(r.latestValues) && St(t, r.latestValues));
+  }
+  e.x < Tt && e.x > bt && (e.x = 1), e.y < Tt && e.y > bt && (e.y = 1);
+}
+function Vt(t, e) {
+  t.min = t.min + e, t.max = t.max + e;
+}
+function At(t, e, n, s, i = 0.5) {
+  const r = Q(t.min, t.max, i);
+  De(t, e, n, r, s);
+}
+function St(t, e) {
+  At(t.x, e.x, e.scaleX, e.scale, e.originX), At(t.y, e.y, e.scaleY, e.scale, e.originY);
+}
+function Sn(t, e) {
+  return nr(sr(t.getBoundingClientRect(), e));
+}
+function Nr(t, e, n) {
+  const s = Sn(t, n), { scroll: i } = e;
+  return i && (Vt(s.x, i.offset.x), Vt(s.y, i.offset.y)), s;
+}
+function wt(t, e) {
+  const n = e ? "pointerenter" : "pointerleave", s = e ? "onHoverStart" : "onHoverEnd", i = (r, o) => {
+    if (r.pointerType === "touch" || Vn())
+      return;
+    const l = t.getProps();
+    t.animationState && l.whileHover && t.animationState.setActive("whileHover", e);
+    const a = l[s];
+    a && P.postRender(() => a(r, o));
+  };
+  return te(t.current, n, i, {
+    passive: !t.getProps()[s]
+  });
+}
+class lr extends W {
+  mount() {
+    this.unmount = K(wt(this.node, !0), wt(this.node, !1));
+  }
+  unmount() {
+  }
+}
+class ur extends W {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let e = !1;
+    try {
+      e = this.node.current.matches(":focus-visible");
+    } catch {
+      e = !0;
+    }
+    !e || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = K(k(this.node.current, "focus", () => this.onFocus()), k(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+const wn = (t, e) => e ? t === e ? !0 : wn(t, e.parentElement) : !1;
+function Te(t, e) {
+  if (!e)
+    return;
+  const n = new PointerEvent("pointer" + t);
+  e(n, bn(n));
+}
+class cr extends W {
+  constructor() {
+    super(...arguments), this.removeStartListeners = I, this.removeEndListeners = I, this.removeAccessibleListeners = I, this.startPointerPress = (e, n) => {
+      if (this.isPressing)
+        return;
+      this.removeEndListeners();
+      const s = this.node.getProps(), r = te(window, "pointerup", (l, a) => {
+        if (!this.checkPressEnd())
+          return;
+        const { onTap: u, onTapCancel: h, globalTapTarget: c } = this.node.getProps(), d = !c && !wn(this.node.current, l.target) ? h : u;
+        d && P.update(() => d(l, a));
+      }, {
+        passive: !(s.onTap || s.onPointerUp)
+      }), o = te(window, "pointercancel", (l, a) => this.cancelPress(l, a), {
+        passive: !(s.onTapCancel || s.onPointerCancel)
+      });
+      this.removeEndListeners = K(r, o), this.startPress(e, n);
+    }, this.startAccessiblePress = () => {
+      const e = (r) => {
+        if (r.key !== "Enter" || this.isPressing)
+          return;
+        const o = (l) => {
+          l.key !== "Enter" || !this.checkPressEnd() || Te("up", (a, u) => {
+            const { onTap: h } = this.node.getProps();
+            h && P.postRender(() => h(a, u));
+          });
+        };
+        this.removeEndListeners(), this.removeEndListeners = k(this.node.current, "keyup", o), Te("down", (l, a) => {
+          this.startPress(l, a);
+        });
+      }, n = k(this.node.current, "keydown", e), s = () => {
+        this.isPressing && Te("cancel", (r, o) => this.cancelPress(r, o));
+      }, i = k(this.node.current, "blur", s);
+      this.removeAccessibleListeners = K(n, i);
+    };
+  }
+  startPress(e, n) {
+    this.isPressing = !0;
+    const { onTapStart: s, whileTap: i } = this.node.getProps();
+    i && this.node.animationState && this.node.animationState.setActive("whileTap", !0), s && P.postRender(() => s(e, n));
+  }
+  checkPressEnd() {
+    return this.removeEndListeners(), this.isPressing = !1, this.node.getProps().whileTap && this.node.animationState && this.node.animationState.setActive("whileTap", !1), !Vn();
+  }
+  cancelPress(e, n) {
+    if (!this.checkPressEnd())
+      return;
+    const { onTapCancel: s } = this.node.getProps();
+    s && P.postRender(() => s(e, n));
+  }
+  mount() {
+    const e = this.node.getProps(), n = te(e.globalTapTarget ? window : this.node.current, "pointerdown", this.startPointerPress, {
+      passive: !(e.onTapStart || e.onPointerStart)
+    }), s = k(this.node.current, "focus", this.startAccessiblePress);
+    this.removeStartListeners = K(n, s);
+  }
+  unmount() {
+    this.removeStartListeners(), this.removeEndListeners(), this.removeAccessibleListeners();
+  }
+}
+const Re = /* @__PURE__ */ new WeakMap(), Ve = /* @__PURE__ */ new WeakMap(), hr = (t) => {
+  const e = Re.get(t.target);
+  e && e(t);
+}, dr = (t) => {
+  t.forEach(hr);
+};
+function fr({ root: t, ...e }) {
+  const n = t || document;
+  Ve.has(n) || Ve.set(n, {});
+  const s = Ve.get(n), i = JSON.stringify(e);
+  return s[i] || (s[i] = new IntersectionObserver(dr, { root: t, ...e })), s[i];
+}
+function pr(t, e, n) {
+  const s = fr(e);
+  return Re.set(t, n), s.observe(t), () => {
+    Re.delete(t), s.unobserve(t);
+  };
+}
+const mr = {
+  some: 0,
+  all: 1
+};
+class gr extends W {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: e = {} } = this.node.getProps(), { root: n, margin: s, amount: i = "some", once: r } = e, o = {
+      root: n ? n.current : void 0,
+      rootMargin: s,
+      threshold: typeof i == "number" ? i : mr[i]
+    }, l = (a) => {
+      const { isIntersecting: u } = a;
+      if (this.isInView === u || (this.isInView = u, r && !u && this.hasEnteredView))
+        return;
+      u && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", u);
+      const { onViewportEnter: h, onViewportLeave: c } = this.node.getProps(), d = u ? h : c;
+      d && d(a);
+    };
+    return pr(this.node.current, o, l);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: e, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(vr(e, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function vr({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (n) => t[n] !== e[n];
+}
+const yr = {
+  inView: {
+    Feature: gr
+  },
+  tap: {
+    Feature: cr
+  },
+  focus: {
+    Feature: ur
+  },
+  hover: {
+    Feature: lr
+  }
+}, Oe = { current: null }, xn = { current: !1 };
+function br() {
+  if (xn.current = !0, !!Gn)
+    if (window.matchMedia) {
+      const t = window.matchMedia("(prefers-reduced-motion)"), e = () => Oe.current = t.matches;
+      t.addListener(e), e();
+    } else
+      Oe.current = !1;
+}
+function Tr(t, e, n) {
+  for (const s in e) {
+    const i = e[s], r = n[s];
+    if (O(i))
+      t.addValue(s, i), ce.env.NODE_ENV === "development" && Ke(i.version === "11.5.6", `Attempting to mix Framer Motion versions ${i.version} with 11.5.6 may not work as expected.`);
+    else if (O(r))
+      t.addValue(s, ae(i, { owner: t }));
+    else if (r !== i)
+      if (t.hasValue(s)) {
+        const o = t.getValue(s);
+        o.liveStyle === !0 ? o.jump(i) : o.hasAnimated || o.set(i);
+      } else {
+        const o = t.getStaticValue(s);
+        t.addValue(s, ae(o !== void 0 ? o : i, { owner: t }));
+      }
+  }
+  for (const s in n)
+    e[s] === void 0 && t.removeValue(s);
+  return e;
+}
+const xt = /* @__PURE__ */ new WeakMap(), Vr = [...Ut, w, j], Ar = (t) => Vr.find(Gt(t)), Pt = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class Sr {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(e, n, s) {
+    return {};
+  }
+  constructor({ parent: e, props: n, presenceContext: s, reducedMotionConfig: i, blockInitialAnimation: r, visualState: o }, l = {}) {
+    this.applyWillChange = !1, this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = Be, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const d = N.now();
+      this.renderScheduledAt < d && (this.renderScheduledAt = d, P.render(this.render, !1, !0));
+    };
+    const { latestValues: a, renderState: u } = o;
+    this.latestValues = a, this.baseTarget = { ...a }, this.initialValues = n.initial ? { ...a } : {}, this.renderState = u, this.parent = e, this.props = n, this.presenceContext = s, this.depth = e ? e.depth + 1 : 0, this.reducedMotionConfig = i, this.options = l, this.blockInitialAnimation = !!r, this.isControllingVariants = Un(n), this.isVariantNode = $n(n), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(e && e.current);
+    const { willChange: h, ...c } = this.scrapeMotionValuesFromProps(n, {}, this);
+    for (const d in c) {
+      const f = c[d];
+      a[d] !== void 0 && O(f) && f.set(a[d], !1);
+    }
+  }
+  mount(e) {
+    this.current = e, xt.set(e, this), this.projection && !this.projection.instance && this.projection.mount(e), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((n, s) => this.bindToMotionValue(s, n)), xn.current || br(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : Oe.current, ce.env.NODE_ENV !== "production" && Ke(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), this.parent && this.parent.children.add(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    xt.delete(this.current), this.projection && this.projection.unmount(), se(this.notifyUpdate), se(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent && this.parent.children.delete(this);
+    for (const e in this.events)
+      this.events[e].clear();
+    for (const e in this.features) {
+      const n = this.features[e];
+      n && (n.unmount(), n.isMounted = !1);
+    }
+    this.current = null;
+  }
+  bindToMotionValue(e, n) {
+    this.valueSubscriptions.has(e) && this.valueSubscriptions.get(e)();
+    const s = Z.has(e), i = n.on("change", (l) => {
+      this.latestValues[e] = l, this.props.onUpdate && P.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0);
+    }), r = n.on("renderRequest", this.scheduleRender);
+    let o;
+    window.MotionCheckAppearSync && (o = window.MotionCheckAppearSync(this, e, n)), this.valueSubscriptions.set(e, () => {
+      i(), r(), o && o(), n.owner && n.stop();
+    });
+  }
+  sortNodePosition(e) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== e.type ? 0 : this.sortInstanceNodePosition(this.current, e.current);
+  }
+  updateFeatures() {
+    let e = "animation";
+    for (e in qe) {
+      const n = qe[e];
+      if (!n)
+        continue;
+      const { isEnabled: s, Feature: i } = n;
+      if (!this.features[e] && i && s(this.props) && (this.features[e] = new i(this)), this.features[e]) {
+        const r = this.features[e];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : An();
+  }
+  getStaticValue(e) {
+    return this.latestValues[e];
+  }
+  setStaticValue(e, n) {
+    this.latestValues[e] = n;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(e, n) {
+    (e.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = e, this.prevPresenceContext = this.presenceContext, this.presenceContext = n;
+    for (let s = 0; s < Pt.length; s++) {
+      const i = Pt[s];
+      this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
+      const r = "on" + i, o = e[r];
+      o && (this.propEventSubscriptions[i] = this.on(i, o));
+    }
+    this.prevMotionValues = Tr(this, this.scrapeMotionValuesFromProps(e, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(e) {
+    return this.props.variants ? this.props.variants[e] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(e) {
+    const n = this.getClosestVariantNode();
+    if (n)
+      return n.variantChildren && n.variantChildren.add(e), () => n.variantChildren.delete(e);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(e, n) {
+    const s = this.values.get(e);
+    n !== s && (s && this.removeValue(e), this.bindToMotionValue(e, n), this.values.set(e, n), this.latestValues[e] = n.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(e) {
+    this.values.delete(e);
+    const n = this.valueSubscriptions.get(e);
+    n && (n(), this.valueSubscriptions.delete(e)), delete this.latestValues[e], this.removeValueFromRenderState(e, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(e) {
+    return this.values.has(e);
+  }
+  getValue(e, n) {
+    if (this.props.values && this.props.values[e])
+      return this.props.values[e];
+    let s = this.values.get(e);
+    return s === void 0 && n !== void 0 && (s = ae(n === null ? void 0 : n, { owner: this }), this.addValue(e, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(e, n) {
+    var s;
+    let i = this.latestValues[e] !== void 0 || !this.current ? this.latestValues[e] : (s = this.getBaseTargetFromProps(this.props, e)) !== null && s !== void 0 ? s : this.readValueFromInstance(this.current, e, this.options);
+    return i != null && (typeof i == "string" && (kt(i) || Lt(i)) ? i = parseFloat(i) : !Ar(i) && j.test(n) && (i = Xt(e, n)), this.setBaseTarget(e, O(i) ? i.get() : i)), O(i) ? i.get() : i;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(e, n) {
+    this.baseTarget[e] = n;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(e) {
+    var n;
+    const { initial: s } = this.props;
+    let i;
+    if (typeof s == "string" || typeof s == "object") {
+      const o = Ct(this.props, s, (n = this.presenceContext) === null || n === void 0 ? void 0 : n.custom);
+      o && (i = o[e]);
+    }
+    if (s && i !== void 0)
+      return i;
+    const r = this.getBaseTargetFromProps(this.props, e);
+    return r !== void 0 && !O(r) ? r : this.initialValues[e] !== void 0 && i === void 0 ? void 0 : this.baseTarget[e];
+  }
+  on(e, n) {
+    return this.events[e] || (this.events[e] = new mn()), this.events[e].add(n);
+  }
+  notify(e, ...n) {
+    this.events[e] && this.events[e].notify(...n);
+  }
+}
+class Pn extends Sr {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = Zt;
+  }
+  sortInstanceNodePosition(e, n) {
+    return e.compareDocumentPosition(n) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e.style ? e.style[n] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: n, style: s }) {
+    delete n[e], delete s[e];
+  }
+}
+function wr(t) {
+  return window.getComputedStyle(t);
+}
+class xr extends Pn {
+  constructor() {
+    super(...arguments), this.type = "html", this.applyWillChange = !0, this.renderInstance = jn;
+  }
+  readValueFromInstance(e, n) {
+    if (Z.has(n)) {
+      const s = ke(n);
+      return s && s.default || 0;
+    } else {
+      const s = wr(e), i = (Wn(n) ? s.getPropertyValue(n) : s[n]) || 0;
+      return typeof i == "string" ? i.trim() : i;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: n }) {
+    return Sn(e, n);
+  }
+  build(e, n, s) {
+    zn(e, n, s.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, n, s) {
+    return Hn(e, n, s);
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    O(e) && (this.childSubscription = e.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+class Pr extends Pn {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = An;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e[n];
+  }
+  readValueFromInstance(e, n) {
+    if (Z.has(n)) {
+      const s = ke(n);
+      return s && s.default || 0;
+    }
+    return n = Yn.has(n) ? n : qn(n), e.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(e, n, s) {
+    return Xn(e, n, s);
+  }
+  build(e, n, s) {
+    Zn(e, n, this.isSVGTag, s.transformTemplate);
+  }
+  renderInstance(e, n, s, i) {
+    Jn(e, n, s, i);
+  }
+  mount(e) {
+    this.isSVGTag = Qn(e.tagName), super.mount(e);
+  }
+}
+const Cr = (t, e) => es(t) ? new Pr(e) : new xr(e, {
+  allowProjection: t !== ts
+}), Kr = {
+  renderer: Cr,
+  ...Ji,
+  ...yr
+};
+export {
+  on as $,
+  ar as A,
+  or as B,
+  Er as C,
+  Or as D,
+  Ni as E,
+  W as F,
+  Kr as G,
+  Ui as H,
+  xt as I,
+  w as J,
+  ut as K,
+  nn as L,
+  Gs as M,
+  gn as N,
+  hn as O,
+  ni as P,
+  Ge as Q,
+  ti as R,
+  mn as S,
+  ln as T,
+  _e as U,
+  Sr as V,
+  ei as W,
+  Xs as X,
+  rn as Y,
+  Zs as Z,
+  J as _,
+  te as a,
+  an as a0,
+  fi as a1,
+  Ji as a2,
+  Vn as a3,
+  er as a4,
+  Q as b,
+  un as c,
+  An as d,
+  bn as e,
+  Nr as f,
+  Ir as g,
+  nr as h,
+  Qi as i,
+  Ri as j,
+  Li as k,
+  k as l,
+  E as m,
+  tr as n,
+  j as o,
+  K as p,
+  Qs as q,
+  vt as r,
+  R as s,
+  N as t,
+  ae as u,
+  Bt as v,
+  rr as w,
+  Vt as x,
+  St as y,
+  ir as z
+};