@js-empire/emperor-ui 1.0.1 → 1.2.0

package/dist/features-animation-D_Ss-HYx.js

@@ -0,0 +1,1938 @@
+import { n as j, v as N, m as U, ac as at, a9 as Zt, aa as rt, aW as Q, X as ge, a8 as Fe, ae as ot, ad as le, h as Oe, t as O, e as Jt, f as G, aZ as Qt, g as _, N as $, Z as lt, _ as en, aX as tn, a5 as Te, aE as nn, a4 as sn, c as an, b as ct, F as rn, aY as on, at as ln, ag as Ie, U as Ee, a$ as q, b0 as Ke, a6 as cn, V as un, a1 as fn, a3 as hn, W as dn, aO as mn, aP as pn, aN as ut, l as yn, ai as gn, aT as Tn, aQ as bn, aR as vn, aC as ft, aG as ht, ay as dt, aF as mt, b1 as xn } from "./index-SRvFgjzo.js";
+import { Fragment as An } from "react";
+// @__NO_SIDE_EFFECTS__
+function be(e) {
+  let t;
+  return () => (t === void 0 && (t = e()), t);
+}
+const wn = (e, t) => (n) => t(e(n)), ee = (...e) => e.reduce(wn), pt = /* @__NO_SIDE_EFFECTS__ */ (e, t, n) => {
+  const i = t - e;
+  return i === 0 ? 1 : (n - e) / i;
+}, F = /* @__NO_SIDE_EFFECTS__ */ (e) => e * 1e3, k = /* @__NO_SIDE_EFFECTS__ */ (e) => e / 1e3, yt = (e, t, n) => (((1 - 3 * n + 3 * t) * e + (3 * n - 6 * t)) * e + 3 * t) * e, Sn = 1e-7, Vn = 12;
+function Dn(e, t, n, i, s) {
+  let a, r, o = 0;
+  do
+    r = t + (n - t) / 2, a = yt(r, i, s) - e, a > 0 ? n = r : t = r;
+  while (Math.abs(a) > Sn && ++o < Vn);
+  return r;
+}
+function z(e, t, n, i) {
+  if (e === t && n === i)
+    return j;
+  const s = (a) => Dn(a, 0, 1, e, n);
+  return (a) => a === 0 || a === 1 ? a : yt(s(a), t, i);
+}
+const gt = (e) => (t) => t <= 0.5 ? e(2 * t) / 2 : (2 - e(2 * (1 - t))) / 2, Tt = (e) => (t) => 1 - e(1 - t), bt = /* @__PURE__ */ z(0.33, 1.53, 0.69, 0.99), ve = /* @__PURE__ */ Tt(bt), vt = /* @__PURE__ */ gt(ve), xt = (e) => (e *= 2) < 1 ? 0.5 * ve(e) : 0.5 * (2 - Math.pow(2, -10 * (e - 1))), xe = (e) => 1 - Math.sin(Math.acos(e)), Mn = Tt(xe), At = gt(xe), Cn = /* @__PURE__ */ z(0.42, 0, 1, 1), Pn = /* @__PURE__ */ z(0, 0, 0.58, 1), wt = /* @__PURE__ */ z(0.42, 0, 0.58, 1), kn = (e) => Array.isArray(e) && typeof e[0] != "number", St = (e) => Array.isArray(e) && typeof e[0] == "number", Re = {
+  linear: j,
+  easeIn: Cn,
+  easeInOut: wt,
+  easeOut: Pn,
+  circIn: xe,
+  circInOut: At,
+  circOut: Mn,
+  backIn: ve,
+  backInOut: vt,
+  backOut: bt,
+  anticipate: xt
+}, Fn = (e) => typeof e == "string", Be = (e) => {
+  if (St(e)) {
+    N(e.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+    const [t, n, i, s] = e;
+    return z(t, n, i, s);
+  } else if (Fn(e))
+    return N(Re[e] !== void 0, `Invalid easing type '${e}'`, "invalid-easing-type"), Re[e];
+  return e;
+};
+function te(e, t, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? e + (t - e) * 6 * n : n < 1 / 2 ? t : n < 2 / 3 ? e + (t - e) * (2 / 3 - n) * 6 : e;
+}
+function On({ hue: e, saturation: t, lightness: n, alpha: i }) {
+  e /= 360, t /= 100, n /= 100;
+  let s = 0, a = 0, r = 0;
+  if (!t)
+    s = a = r = n;
+  else {
+    const o = n < 0.5 ? n * (1 + t) : n + t - n * t, c = 2 * n - o;
+    s = te(c, o, e + 1 / 3), a = te(c, o, e), r = te(c, o, e - 1 / 3);
+  }
+  return {
+    red: Math.round(s * 255),
+    green: Math.round(a * 255),
+    blue: Math.round(r * 255),
+    alpha: i
+  };
+}
+function Y(e, t) {
+  return (n) => n > 0 ? t : e;
+}
+const ne = (e, t, n) => {
+  const i = e * e, s = n * (t * t - i) + i;
+  return s < 0 ? 0 : Math.sqrt(s);
+}, In = [Zt, at, rt], En = (e) => In.find((t) => t.test(e));
+function Le(e) {
+  const t = En(e);
+  if (Q(!!t, `'${e}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !t)
+    return !1;
+  let n = t.parse(e);
+  return t === rt && (n = On(n)), n;
+}
+const Ne = (e, t) => {
+  const n = Le(e), i = Le(t);
+  if (!n || !i)
+    return Y(e, t);
+  const s = { ...n };
+  return (a) => (s.red = ne(n.red, i.red, a), s.green = ne(n.green, i.green, a), s.blue = ne(n.blue, i.blue, a), s.alpha = U(n.alpha, i.alpha, a), at.transform(s));
+}, ce = /* @__PURE__ */ new Set(["none", "hidden"]);
+function Kn(e, t) {
+  return ce.has(e) ? (n) => n <= 0 ? e : t : (n) => n >= 1 ? t : e;
+}
+function Rn(e, t) {
+  return (n) => U(e, t, n);
+}
+function Ae(e) {
+  return typeof e == "number" ? Rn : typeof e == "string" ? ge(e) ? Y : Fe.test(e) ? Ne : Nn : Array.isArray(e) ? Vt : typeof e == "object" ? Fe.test(e) ? Ne : Bn : Y;
+}
+function Vt(e, t) {
+  const n = [...e], i = n.length, s = e.map((a, r) => Ae(a)(a, t[r]));
+  return (a) => {
+    for (let r = 0; r < i; r++)
+      n[r] = s[r](a);
+    return n;
+  };
+}
+function Bn(e, t) {
+  const n = { ...e, ...t }, i = {};
+  for (const s in n)
+    e[s] !== void 0 && t[s] !== void 0 && (i[s] = Ae(e[s])(e[s], t[s]));
+  return (s) => {
+    for (const a in i)
+      n[a] = i[a](s);
+    return n;
+  };
+}
+function Ln(e, t) {
+  const n = [], i = { color: 0, var: 0, number: 0 };
+  for (let s = 0; s < t.values.length; s++) {
+    const a = t.types[s], r = e.indexes[a][i[a]], o = e.values[r] ?? 0;
+    n[s] = o, i[a]++;
+  }
+  return n;
+}
+const Nn = (e, t) => {
+  const n = ot.createTransformer(t), i = le(e), s = le(t);
+  return i.indexes.var.length === s.indexes.var.length && i.indexes.color.length === s.indexes.color.length && i.indexes.number.length >= s.indexes.number.length ? ce.has(e) && !s.values.length || ce.has(t) && !i.values.length ? Kn(e, t) : ee(Vt(Ln(i, s), s.values), n) : (Q(!0, `Complex values '${e}' and '${t}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different"), Y(e, t));
+};
+function Dt(e, t, n) {
+  return typeof e == "number" && typeof t == "number" && typeof n == "number" ? U(e, t, n) : Ae(e)(e, t);
+}
+const Gn = (e) => {
+  const t = ({ timestamp: n }) => e(n);
+  return {
+    start: (n = !0) => G.update(t, n),
+    stop: () => Jt(t),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => Oe.isProcessing ? Oe.timestamp : O.now()
+  };
+}, Mt = (e, t, n = 10) => {
+  let i = "";
+  const s = Math.max(Math.round(t / n), 2);
+  for (let a = 0; a < s; a++)
+    i += Math.round(e(a / (s - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${i.substring(0, i.length - 2)})`;
+}, Z = 2e4;
+function we(e) {
+  let t = 0;
+  const n = 50;
+  let i = e.next(t);
+  for (; !i.done && t < Z; )
+    t += n, i = e.next(t);
+  return t >= Z ? 1 / 0 : t;
+}
+function _n(e, t = 100, n) {
+  const i = n({ ...e, keyframes: [0, t] }), s = Math.min(we(i), Z);
+  return {
+    type: "keyframes",
+    ease: (a) => i.next(s * a).value / t,
+    duration: /* @__PURE__ */ k(s)
+  };
+}
+const $n = 5;
+function Ct(e, t, n) {
+  const i = Math.max(t - $n, 0);
+  return Qt(n - e(i), t - i);
+}
+const w = {
+  // Default spring physics
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 0,
+  // Default duration/bounce-based options
+  duration: 800,
+  // in ms
+  bounce: 0.3,
+  visualDuration: 0.3,
+  // in seconds
+  // Rest thresholds
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  // Limits
+  minDuration: 0.01,
+  // in seconds
+  maxDuration: 10,
+  // in seconds
+  minDamping: 0.05,
+  maxDamping: 1
+}, ie = 1e-3;
+function Wn({ duration: e = w.duration, bounce: t = w.bounce, velocity: n = w.velocity, mass: i = w.mass }) {
+  let s, a;
+  Q(e <= /* @__PURE__ */ F(w.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let r = 1 - t;
+  r = _(w.minDamping, w.maxDamping, r), e = _(w.minDuration, w.maxDuration, /* @__PURE__ */ k(e)), r < 1 ? (s = (u) => {
+    const l = u * r, f = l * e, h = l - n, p = ue(u, r), b = Math.exp(-f);
+    return ie - h / p * b;
+  }, a = (u) => {
+    const f = u * r * e, h = f * n + n, p = Math.pow(r, 2) * Math.pow(u, 2) * e, b = Math.exp(-f), g = ue(Math.pow(u, 2), r);
+    return (-s(u) + ie > 0 ? -1 : 1) * ((h - p) * b) / g;
+  }) : (s = (u) => {
+    const l = Math.exp(-u * e), f = (u - n) * e + 1;
+    return -ie + l * f;
+  }, a = (u) => {
+    const l = Math.exp(-u * e), f = (n - u) * (e * e);
+    return l * f;
+  });
+  const o = 5 / e, c = jn(s, a, o);
+  if (e = /* @__PURE__ */ F(e), isNaN(c))
+    return {
+      stiffness: w.stiffness,
+      damping: w.damping,
+      duration: e
+    };
+  {
+    const u = Math.pow(c, 2) * i;
+    return {
+      stiffness: u,
+      damping: r * 2 * Math.sqrt(i * u),
+      duration: e
+    };
+  }
+}
+const Hn = 12;
+function jn(e, t, n) {
+  let i = n;
+  for (let s = 1; s < Hn; s++)
+    i = i - e(i) / t(i);
+  return i;
+}
+function ue(e, t) {
+  return e * Math.sqrt(1 - t * t);
+}
+const Un = ["duration", "bounce"], zn = ["stiffness", "damping", "mass"];
+function Ge(e, t) {
+  return t.some((n) => e[n] !== void 0);
+}
+function qn(e) {
+  let t = {
+    velocity: w.velocity,
+    stiffness: w.stiffness,
+    damping: w.damping,
+    mass: w.mass,
+    isResolvedFromDuration: !1,
+    ...e
+  };
+  if (!Ge(e, zn) && Ge(e, Un))
+    if (e.visualDuration) {
+      const n = e.visualDuration, i = 2 * Math.PI / (n * 1.2), s = i * i, a = 2 * _(0.05, 1, 1 - (e.bounce || 0)) * Math.sqrt(s);
+      t = {
+        ...t,
+        mass: w.mass,
+        stiffness: s,
+        damping: a
+      };
+    } else {
+      const n = Wn(e);
+      t = {
+        ...t,
+        ...n,
+        mass: w.mass
+      }, t.isResolvedFromDuration = !0;
+    }
+  return t;
+}
+function J(e = w.visualDuration, t = w.bounce) {
+  const n = typeof e != "object" ? {
+    visualDuration: e,
+    keyframes: [0, 1],
+    bounce: t
+  } : e;
+  let { restSpeed: i, restDelta: s } = n;
+  const a = n.keyframes[0], r = n.keyframes[n.keyframes.length - 1], o = { done: !1, value: a }, { stiffness: c, damping: u, mass: l, duration: f, velocity: h, isResolvedFromDuration: p } = qn({
+    ...n,
+    velocity: -/* @__PURE__ */ k(n.velocity || 0)
+  }), b = h || 0, g = u / (2 * Math.sqrt(c * l)), T = r - a, d = /* @__PURE__ */ k(Math.sqrt(c / l)), v = Math.abs(T) < 5;
+  i || (i = v ? w.restSpeed.granular : w.restSpeed.default), s || (s = v ? w.restDelta.granular : w.restDelta.default);
+  let x;
+  if (g < 1) {
+    const m = ue(d, g);
+    x = (A) => {
+      const S = Math.exp(-g * d * A);
+      return r - S * ((b + g * d * T) / m * Math.sin(m * A) + T * Math.cos(m * A));
+    };
+  } else if (g === 1)
+    x = (m) => r - Math.exp(-d * m) * (T + (b + d * T) * m);
+  else {
+    const m = d * Math.sqrt(g * g - 1);
+    x = (A) => {
+      const S = Math.exp(-g * d * A), y = Math.min(m * A, 300);
+      return r - S * ((b + g * d * T) * Math.sinh(y) + m * T * Math.cosh(y)) / m;
+    };
+  }
+  const M = {
+    calculatedDuration: p && f || null,
+    next: (m) => {
+      const A = x(m);
+      if (p)
+        o.done = m >= f;
+      else {
+        let S = m === 0 ? b : 0;
+        g < 1 && (S = m === 0 ? /* @__PURE__ */ F(b) : Ct(x, m, A));
+        const y = Math.abs(S) <= i, D = Math.abs(r - A) <= s;
+        o.done = y && D;
+      }
+      return o.value = o.done ? r : A, o;
+    },
+    toString: () => {
+      const m = Math.min(we(M), Z), A = Mt((S) => M.next(m * S).value, m, 30);
+      return m + "ms " + A;
+    },
+    toTransition: () => {
+    }
+  };
+  return M;
+}
+J.applyToOptions = (e) => {
+  const t = _n(e, 100, J);
+  return e.ease = t.ease, e.duration = /* @__PURE__ */ F(t.duration), e.type = "keyframes", e;
+};
+function fe({ keyframes: e, velocity: t = 0, power: n = 0.8, timeConstant: i = 325, bounceDamping: s = 10, bounceStiffness: a = 500, modifyTarget: r, min: o, max: c, restDelta: u = 0.5, restSpeed: l }) {
+  const f = e[0], h = {
+    done: !1,
+    value: f
+  }, p = (y) => o !== void 0 && y < o || c !== void 0 && y > c, b = (y) => o === void 0 ? c : c === void 0 || Math.abs(o - y) < Math.abs(c - y) ? o : c;
+  let g = n * t;
+  const T = f + g, d = r === void 0 ? T : r(T);
+  d !== T && (g = d - f);
+  const v = (y) => -g * Math.exp(-y / i), x = (y) => d + v(y), M = (y) => {
+    const D = v(y), C = x(y);
+    h.done = Math.abs(D) <= u, h.value = h.done ? d : C;
+  };
+  let m, A;
+  const S = (y) => {
+    p(h.value) && (m = y, A = J({
+      keyframes: [h.value, b(h.value)],
+      velocity: Ct(x, y, h.value),
+      // TODO: This should be passing * 1000
+      damping: s,
+      stiffness: a,
+      restDelta: u,
+      restSpeed: l
+    }));
+  };
+  return S(0), {
+    calculatedDuration: null,
+    next: (y) => {
+      let D = !1;
+      return !A && m === void 0 && (D = !0, M(y), S(y)), m !== void 0 && y >= m ? A.next(y - m) : (!D && M(y), h);
+    }
+  };
+}
+function Xn(e, t, n) {
+  const i = [], s = n || $.mix || Dt, a = e.length - 1;
+  for (let r = 0; r < a; r++) {
+    let o = s(e[r], e[r + 1]);
+    if (t) {
+      const c = Array.isArray(t) ? t[r] || j : t;
+      o = ee(c, o);
+    }
+    i.push(o);
+  }
+  return i;
+}
+function Yn(e, t, { clamp: n = !0, ease: i, mixer: s } = {}) {
+  const a = e.length;
+  if (N(a === t.length, "Both input and output ranges must be the same length", "range-length"), a === 1)
+    return () => t[0];
+  if (a === 2 && t[0] === t[1])
+    return () => t[1];
+  const r = e[0] === e[1];
+  e[0] > e[a - 1] && (e = [...e].reverse(), t = [...t].reverse());
+  const o = Xn(t, i, s), c = o.length, u = (l) => {
+    if (r && l < e[0])
+      return t[0];
+    let f = 0;
+    if (c > 1)
+      for (; f < e.length - 2 && !(l < e[f + 1]); f++)
+        ;
+    const h = /* @__PURE__ */ pt(e[f], e[f + 1], l);
+    return o[f](h);
+  };
+  return n ? (l) => u(_(e[0], e[a - 1], l)) : u;
+}
+function Zn(e, t) {
+  const n = e[e.length - 1];
+  for (let i = 1; i <= t; i++) {
+    const s = /* @__PURE__ */ pt(0, t, i);
+    e.push(U(n, 1, s));
+  }
+}
+function Jn(e) {
+  const t = [0];
+  return Zn(t, e.length - 1), t;
+}
+function Qn(e, t) {
+  return e.map((n) => n * t);
+}
+function ei(e, t) {
+  return e.map(() => t || wt).splice(0, e.length - 1);
+}
+function B({ duration: e = 300, keyframes: t, times: n, ease: i = "easeInOut" }) {
+  const s = kn(i) ? i.map(Be) : Be(i), a = {
+    done: !1,
+    value: t[0]
+  }, r = Qn(
+    // 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 === t.length ? n : Jn(t),
+    e
+  ), o = Yn(r, t, {
+    ease: Array.isArray(s) ? s : ei(t, s)
+  });
+  return {
+    calculatedDuration: e,
+    next: (c) => (a.value = o(c), a.done = c >= e, a)
+  };
+}
+const ti = (e) => e !== null;
+function Se(e, { repeat: t, repeatType: n = "loop" }, i, s = 1) {
+  const a = e.filter(ti), o = s < 0 || t && n !== "loop" && t % 2 === 1 ? 0 : a.length - 1;
+  return !o || i === void 0 ? a[o] : i;
+}
+const ni = {
+  decay: fe,
+  inertia: fe,
+  tween: B,
+  keyframes: B,
+  spring: J
+};
+function Pt(e) {
+  typeof e.type == "string" && (e.type = ni[e.type]);
+}
+class Ve {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((t) => {
+      this.resolve = t;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  /**
+   * Allows the animation to be awaited.
+   *
+   * @deprecated Use `finished` instead.
+   */
+  then(t, n) {
+    return this.finished.then(t, n);
+  }
+}
+const ii = (e) => e / 100;
+class De extends Ve {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+      const { motionValue: n } = this.options;
+      n && n.updatedAt !== O.now() && this.tick(O.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: t } = this;
+    Pt(t);
+    const { type: n = B, repeat: i = 0, repeatDelay: s = 0, repeatType: a, velocity: r = 0 } = t;
+    let { keyframes: o } = t;
+    const c = n || B;
+    process.env.NODE_ENV !== "production" && c !== B && N(o.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${o}`, "spring-two-frames"), c !== B && typeof o[0] != "number" && (this.mixKeyframes = ee(ii, Dt(o[0], o[1])), o = [0, 100]);
+    const u = c({ ...t, keyframes: o });
+    a === "mirror" && (this.mirroredGenerator = c({
+      ...t,
+      keyframes: [...o].reverse(),
+      velocity: -r
+    })), u.calculatedDuration === null && (u.calculatedDuration = we(u));
+    const { calculatedDuration: l } = u;
+    this.calculatedDuration = l, this.resolvedDuration = l + s, this.totalDuration = this.resolvedDuration * (i + 1) - s, this.generator = u;
+  }
+  updateTime(t) {
+    const n = Math.round(t - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = n;
+  }
+  tick(t, n = !1) {
+    const { generator: i, totalDuration: s, mixKeyframes: a, mirroredGenerator: r, resolvedDuration: o, calculatedDuration: c } = this;
+    if (this.startTime === null)
+      return i.next(0);
+    const { delay: u = 0, keyframes: l, repeat: f, repeatType: h, repeatDelay: p, type: b, onUpdate: g, finalKeyframe: T } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), n ? this.currentTime = t : this.updateTime(t);
+    const d = this.currentTime - u * (this.playbackSpeed >= 0 ? 1 : -1), v = this.playbackSpeed >= 0 ? d < 0 : d > s;
+    this.currentTime = Math.max(d, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
+    let x = this.currentTime, M = i;
+    if (f) {
+      const y = Math.min(this.currentTime, s) / o;
+      let D = Math.floor(y), C = y % 1;
+      !C && y >= 1 && (C = 1), C === 1 && D--, D = Math.min(D, f + 1), D % 2 && (h === "reverse" ? (C = 1 - C, p && (C -= p / o)) : h === "mirror" && (M = r)), x = _(0, 1, C) * o;
+    }
+    const m = v ? { done: !1, value: l[0] } : M.next(x);
+    a && (m.value = a(m.value));
+    let { done: A } = m;
+    !v && c !== null && (A = this.playbackSpeed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
+    const S = this.holdTime === null && (this.state === "finished" || this.state === "running" && A);
+    return S && b !== fe && (m.value = Se(l, this.options, T, this.speed)), g && g(m.value), S && this.finish(), m;
+  }
+  /**
+   * 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(t, n) {
+    return this.finished.then(t, n);
+  }
+  get duration() {
+    return /* @__PURE__ */ k(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ k(t);
+  }
+  get time() {
+    return /* @__PURE__ */ k(this.currentTime);
+  }
+  set time(t) {
+    t = /* @__PURE__ */ F(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), this.driver?.start(!1);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    this.updateTime(O.now());
+    const n = this.playbackSpeed !== t;
+    this.playbackSpeed = t, n && (this.time = /* @__PURE__ */ k(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: t = Gn, startTime: n } = this.options;
+    this.driver || (this.driver = t((s) => this.tick(s))), this.options.onPlay?.();
+    const i = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = i) : this.holdTime !== null ? this.startTime = i - this.holdTime : this.startTime || (this.startTime = n ?? i), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(O.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+  attachTimeline(t) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), t.observe(this);
+  }
+}
+const si = (e) => e.startsWith("--");
+function ai(e, t, n) {
+  si(t) ? e.style.setProperty(t, n) : e.style[t] = n;
+}
+const ri = /* @__PURE__ */ be(() => window.ScrollTimeline !== void 0), oi = {};
+function li(e, t) {
+  const n = /* @__PURE__ */ be(e);
+  return () => oi[t] ?? n();
+}
+const kt = /* @__PURE__ */ li(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing"), H = ([e, t, n, i]) => `cubic-bezier(${e}, ${t}, ${n}, ${i})`, _e = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ H([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ H([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ H([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ H([0.33, 1.53, 0.69, 0.99])
+};
+function Ft(e, t) {
+  if (e)
+    return typeof e == "function" ? kt() ? Mt(e, t) : "ease-out" : St(e) ? H(e) : Array.isArray(e) ? e.map((n) => Ft(n, t) || _e.easeOut) : _e[e];
+}
+function ci(e, t, n, { delay: i = 0, duration: s = 300, repeat: a = 0, repeatType: r = "loop", ease: o = "easeOut", times: c } = {}, u = void 0) {
+  const l = {
+    [t]: n
+  };
+  c && (l.offset = c);
+  const f = Ft(o, s);
+  Array.isArray(f) && (l.easing = f);
+  const h = {
+    delay: i,
+    duration: s,
+    easing: Array.isArray(f) ? "linear" : f,
+    fill: "both",
+    iterations: a + 1,
+    direction: r === "reverse" ? "alternate" : "normal"
+  };
+  return u && (h.pseudoElement = u), e.animate(l, h);
+}
+function Ot(e) {
+  return typeof e == "function" && "applyToOptions" in e;
+}
+function ui({ type: e, ...t }) {
+  return Ot(e) && kt() ? e.applyToOptions(t) : (t.duration ?? (t.duration = 300), t.ease ?? (t.ease = "easeOut"), t);
+}
+class fi extends Ve {
+  constructor(t) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !t)
+      return;
+    const { element: n, name: i, keyframes: s, pseudoElement: a, allowFlatten: r = !1, finalKeyframe: o, onComplete: c } = t;
+    this.isPseudoElement = !!a, this.allowFlatten = r, this.options = t, N(typeof t.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
+    const u = ui(t);
+    this.animation = ci(n, i, s, u, a), u.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !a) {
+        const l = Se(s, this.options, o, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(l) : ai(n, i, l), this.animation.cancel();
+      }
+      c?.(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.finish?.();
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: t } = this;
+    t === "idle" || t === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * In this method, we commit styles back to the DOM before cancelling
+   * the animation.
+   *
+   * This is designed to be overridden by NativeAnimationExtended, which
+   * will create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to also correctly calculate velocity for any subsequent animation
+   * while deferring the commit until the next animation frame.
+   */
+  commitStyles() {
+    this.isPseudoElement || this.animation.commitStyles?.();
+  }
+  get duration() {
+    const t = this.animation.effect?.getComputedTiming?.().duration || 0;
+    return /* @__PURE__ */ k(Number(t));
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ k(t);
+  }
+  get time() {
+    return /* @__PURE__ */ k(Number(this.animation.currentTime) || 0);
+  }
+  set time(t) {
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ F(t);
+  }
+  /**
+   * The playback speed of the animation.
+   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+   */
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(t) {
+    t < 0 && (this.finishedTime = null), this.animation.playbackRate = t;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(t) {
+    this.manualStartTime = this.animation.startTime = t;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: t, observe: n }) {
+    return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, t && ri() ? (this.animation.timeline = t, j) : n(this);
+  }
+}
+const It = {
+  anticipate: xt,
+  backInOut: vt,
+  circInOut: At
+};
+function hi(e) {
+  return e in It;
+}
+function di(e) {
+  typeof e.ease == "string" && hi(e.ease) && (e.ease = It[e.ease]);
+}
+const se = 10;
+class mi extends fi {
+  constructor(t) {
+    di(t), Pt(t), super(t), t.startTime !== void 0 && (this.startTime = t.startTime), this.options = t;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read committed styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
+   */
+  updateMotionValue(t) {
+    const { motionValue: n, onUpdate: i, onComplete: s, element: a, ...r } = this.options;
+    if (!n)
+      return;
+    if (t !== void 0) {
+      n.set(t);
+      return;
+    }
+    const o = new De({
+      ...r,
+      autoplay: !1
+    }), c = Math.max(se, O.now() - this.startTime), u = _(0, se, c - se);
+    n.setWithVelocity(o.sample(Math.max(0, c - u)).value, o.sample(c).value, u), o.stop();
+  }
+}
+const $e = (e, t) => t === "zIndex" ? !1 : !!(typeof e == "number" || Array.isArray(e) || typeof e == "string" && // It's animatable if we have a string
+(ot.test(e) || e === "0") && // And it contains numbers and/or colors
+!e.startsWith("url("));
+function pi(e) {
+  const t = e[0];
+  if (e.length === 1)
+    return !0;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t)
+      return !0;
+}
+function yi(e, t, n, i) {
+  const s = e[0];
+  if (s === null)
+    return !1;
+  if (t === "display" || t === "visibility")
+    return !0;
+  const a = e[e.length - 1], r = $e(s, t), o = $e(a, t);
+  return Q(r === o, `You are trying to animate ${t} from "${s}" to "${a}". "${r ? a : s}" is not an animatable value.`, "value-not-animatable"), !r || !o ? !1 : pi(e) || (n === "spring" || Ot(n)) && i;
+}
+function he(e) {
+  e.duration = 0, e.type = "keyframes";
+}
+const gi = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Could be re-enabled now we have support for linear() easing
+  // "background-color"
+]), Ti = /* @__PURE__ */ be(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function bi(e) {
+  const { motionValue: t, name: n, repeatDelay: i, repeatType: s, damping: a, type: r } = e;
+  if (!(t?.owner?.current instanceof HTMLElement))
+    return !1;
+  const { onUpdate: c, transformTemplate: u } = t.owner.getProps();
+  return Ti() && n && gi.has(n) && (n !== "transform" || !u) && /**
+   * 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.
+   */
+  !c && !i && s !== "mirror" && a !== 0 && r !== "inertia";
+}
+const vi = 40;
+class xi extends Ve {
+  constructor({ autoplay: t = !0, delay: n = 0, type: i = "keyframes", repeat: s = 0, repeatDelay: a = 0, repeatType: r = "loop", keyframes: o, name: c, motionValue: u, element: l, ...f }) {
+    super(), this.stop = () => {
+      this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+    }, this.createdAt = O.now();
+    const h = {
+      autoplay: t,
+      delay: n,
+      type: i,
+      repeat: s,
+      repeatDelay: a,
+      repeatType: r,
+      name: c,
+      motionValue: u,
+      element: l,
+      ...f
+    }, p = l?.KeyframeResolver || lt;
+    this.keyframeResolver = new p(o, (b, g, T) => this.onKeyframesResolved(b, g, h, !T), c, u, l), this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(t, n, i, s) {
+    this.keyframeResolver = void 0;
+    const { name: a, type: r, velocity: o, delay: c, isHandoff: u, onUpdate: l } = i;
+    this.resolvedAt = O.now(), yi(t, a, r, o) || (($.instantAnimations || !c) && l?.(Se(t, i, n)), t[0] = t[t.length - 1], he(i), i.repeat = 0);
+    const h = {
+      startTime: s ? this.resolvedAt ? this.resolvedAt - this.createdAt > vi ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: n,
+      ...i,
+      keyframes: t
+    }, p = !u && bi(h), b = h.motionValue?.owner?.current, g = p ? new mi({
+      ...h,
+      element: b
+    }) : new De(h);
+    g.finished.then(() => {
+      this.notifyFinished();
+    }).catch(j), this.pendingTimeline && (this.stopTimeline = g.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = g;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(t, n) {
+    return this.finished.finally(t).then(() => {
+    });
+  }
+  get animation() {
+    return this._animation || (this.keyframeResolver?.resume(), en()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(t) {
+    this.animation.time = t;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(t) {
+    this.animation.speed = t;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(t) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(t) : this.pendingTimeline = t, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+  }
+}
+function Et(e, t, n, i = 0, s = 1) {
+  const a = Array.from(e).sort((u, l) => u.sortNodePosition(l)).indexOf(t), r = e.size, o = (r - 1) * i;
+  return typeof n == "function" ? n(a, r) : s === 1 ? a * i : o - a * i;
+}
+const Ai = (
+  // 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 wi(e) {
+  const t = Ai.exec(e);
+  if (!t)
+    return [,];
+  const [, n, i, s] = t;
+  return [`--${n ?? i}`, s];
+}
+const Si = 4;
+function Kt(e, t, n = 1) {
+  N(n <= Si, `Max CSS variable fallback depth detected in property "${e}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [i, s] = wi(e);
+  if (!i)
+    return;
+  const a = window.getComputedStyle(t).getPropertyValue(i);
+  if (a) {
+    const r = a.trim();
+    return tn(r) ? parseFloat(r) : r;
+  }
+  return ge(s) ? Kt(s, t, n + 1) : s;
+}
+const Vi = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, Di = (e) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: e === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), Mi = {
+  type: "keyframes",
+  duration: 0.8
+}, Ci = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, Pi = (e, { keyframes: t }) => t.length > 2 ? Mi : Te.has(e) ? e.startsWith("scale") ? Di(t[1]) : Vi : Ci, ki = (e) => e !== null;
+function Fi(e, { repeat: t, repeatType: n = "loop" }, i) {
+  const s = e.filter(ki), a = t && n !== "loop" && t % 2 === 1 ? 0 : s.length - 1;
+  return s[a];
+}
+function Rt(e, t) {
+  return e?.[t] ?? e?.default ?? e;
+}
+function Oi({ when: e, delay: t, delayChildren: n, staggerChildren: i, staggerDirection: s, repeat: a, repeatType: r, repeatDelay: o, from: c, elapsed: u, ...l }) {
+  return !!Object.keys(l).length;
+}
+const Ii = (e, t, n, i = {}, s, a) => (r) => {
+  const o = Rt(i, e) || {}, c = o.delay || i.delay || 0;
+  let { elapsed: u = 0 } = i;
+  u = u - /* @__PURE__ */ F(c);
+  const l = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: t.getVelocity(),
+    ...o,
+    delay: -u,
+    onUpdate: (h) => {
+      t.set(h), o.onUpdate && o.onUpdate(h);
+    },
+    onComplete: () => {
+      r(), o.onComplete && o.onComplete();
+    },
+    name: e,
+    motionValue: t,
+    element: a ? void 0 : s
+  };
+  Oi(o) || Object.assign(l, Pi(e, l)), l.duration && (l.duration = /* @__PURE__ */ F(l.duration)), l.repeatDelay && (l.repeatDelay = /* @__PURE__ */ F(l.repeatDelay)), l.from !== void 0 && (l.keyframes[0] = l.from);
+  let f = !1;
+  if ((l.type === !1 || l.duration === 0 && !l.repeatDelay) && (he(l), l.delay === 0 && (f = !0)), ($.instantAnimations || $.skipAnimations) && (f = !0, he(l), l.delay = 0), l.allowFlatten = !o.type && !o.ease, f && !a && t.get() !== void 0) {
+    const h = Fi(l.keyframes, o);
+    if (h !== void 0) {
+      G.update(() => {
+        l.onUpdate(h), l.onComplete();
+      });
+      return;
+    }
+  }
+  return o.isSync ? new De(l) : new xi(l);
+};
+function L(e, t, n) {
+  const i = e.getProps();
+  return nn(i, t, n !== void 0 ? n : i.custom, e);
+}
+const Bt = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...sn
+]), de = (e) => Array.isArray(e);
+function Ei(e, t, n) {
+  e.hasValue(t) ? e.getValue(t).set(n) : e.addValue(t, an(n));
+}
+function Ki(e) {
+  return de(e) ? e[e.length - 1] || 0 : e;
+}
+function Ri(e, t) {
+  const n = L(e, t);
+  let { transitionEnd: i = {}, transition: s = {}, ...a } = n || {};
+  a = { ...a, ...i };
+  for (const r in a) {
+    const o = Ki(a[r]);
+    Ei(e, r, o);
+  }
+}
+function Bi(e) {
+  return !!(ct(e) && e.add);
+}
+function Li(e, t) {
+  const n = e.getValue("willChange");
+  if (Bi(n))
+    return n.add(t);
+  if (!n && $.WillChange) {
+    const i = new $.WillChange("auto");
+    e.addValue("willChange", i), i.add(t);
+  }
+}
+function Ni(e) {
+  return e.props[rn];
+}
+function Gi({ protectedKeys: e, needsAnimating: t }, n) {
+  const i = e.hasOwnProperty(n) && t[n] !== !0;
+  return t[n] = !1, i;
+}
+function Lt(e, t, { delay: n = 0, transitionOverride: i, type: s } = {}) {
+  let { transition: a = e.getDefaultTransition(), transitionEnd: r, ...o } = t;
+  i && (a = i);
+  const c = [], u = s && e.animationState && e.animationState.getState()[s];
+  for (const l in o) {
+    const f = e.getValue(l, e.latestValues[l] ?? null), h = o[l];
+    if (h === void 0 || u && Gi(u, l))
+      continue;
+    const p = {
+      delay: n,
+      ...Rt(a || {}, l)
+    }, b = f.get();
+    if (b !== void 0 && !f.isAnimating && !Array.isArray(h) && h === b && !p.velocity)
+      continue;
+    let g = !1;
+    if (window.MotionHandoffAnimation) {
+      const d = Ni(e);
+      if (d) {
+        const v = window.MotionHandoffAnimation(d, l, G);
+        v !== null && (p.startTime = v, g = !0);
+      }
+    }
+    Li(e, l), f.start(Ii(l, f, h, e.shouldReduceMotion && Bt.has(l) ? { type: !1 } : p, e, g));
+    const T = f.animation;
+    T && c.push(T);
+  }
+  return r && Promise.all(c).then(() => {
+    G.update(() => {
+      r && Ri(e, r);
+    });
+  }), c;
+}
+function me(e, t, n = {}) {
+  const i = L(e, t, n.type === "exit" ? e.presenceContext?.custom : void 0);
+  let { transition: s = e.getDefaultTransition() || {} } = i || {};
+  n.transitionOverride && (s = n.transitionOverride);
+  const a = i ? () => Promise.all(Lt(e, i, n)) : () => Promise.resolve(), r = e.variantChildren && e.variantChildren.size ? (c = 0) => {
+    const { delayChildren: u = 0, staggerChildren: l, staggerDirection: f } = s;
+    return _i(e, t, c, u, l, f, n);
+  } : () => Promise.resolve(), { when: o } = s;
+  if (o) {
+    const [c, u] = o === "beforeChildren" ? [a, r] : [r, a];
+    return c().then(() => u());
+  } else
+    return Promise.all([a(), r(n.delay)]);
+}
+function _i(e, t, n = 0, i = 0, s = 0, a = 1, r) {
+  const o = [];
+  for (const c of e.variantChildren)
+    c.notify("AnimationStart", t), o.push(me(c, t, {
+      ...r,
+      delay: n + (typeof i == "function" ? 0 : i) + Et(e.variantChildren, c, i, s, a)
+    }).then(() => c.notify("AnimationComplete", t)));
+  return Promise.all(o);
+}
+function $i(e, t, n = {}) {
+  e.notify("AnimationStart", t);
+  let i;
+  if (Array.isArray(t)) {
+    const s = t.map((a) => me(e, a, n));
+    i = Promise.all(s);
+  } else if (typeof t == "string")
+    i = me(e, t, n);
+  else {
+    const s = typeof t == "function" ? L(e, t, n.custom) : t;
+    i = Promise.all(Lt(e, s, n));
+  }
+  return i.then(() => {
+    e.notify("AnimationComplete", t);
+  });
+}
+function Wi(e) {
+  return typeof e == "number" ? e === 0 : e !== null ? e === "none" || e === "0" || on(e) : !0;
+}
+const Hi = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function ji(e, t, n) {
+  let i = 0, s;
+  for (; i < e.length && !s; ) {
+    const a = e[i];
+    typeof a == "string" && !Hi.has(a) && le(a).values.length && (s = e[i]), i++;
+  }
+  if (s && n)
+    for (const a of t)
+      e[a] = ln(n, s);
+}
+class Ui extends lt {
+  constructor(t, n, i, s, a) {
+    super(t, n, i, s, a, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: t, element: n, name: i } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let l = 0; l < t.length; l++) {
+      let f = t[l];
+      if (typeof f == "string" && (f = f.trim(), ge(f))) {
+        const h = Kt(f, n.current);
+        h !== void 0 && (t[l] = h), l === t.length - 1 && (this.finalKeyframe = f);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !Bt.has(i) || t.length !== 2)
+      return;
+    const [s, a] = t, r = Ie(s), o = Ie(a), c = Ee(s), u = Ee(a);
+    if (c !== u && q[i]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (r !== o)
+      if (Ke(r) && Ke(o))
+        for (let l = 0; l < t.length; l++) {
+          const f = t[l];
+          typeof f == "string" && (t[l] = parseFloat(f));
+        }
+      else q[i] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: t, name: n } = this, i = [];
+    for (let s = 0; s < t.length; s++)
+      (t[s] === null || Wi(t[s])) && i.push(s);
+    i.length && ji(t, i, n);
+  }
+  measureInitialState() {
+    const { element: t, unresolvedKeyframes: n, name: i } = this;
+    if (!t || !t.current)
+      return;
+    i === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = q[i](t.measureViewportBox(), window.getComputedStyle(t.current)), n[0] = this.measuredOrigin;
+    const s = n[n.length - 1];
+    s !== void 0 && t.getValue(i, s).jump(s, !1);
+  }
+  measureEndState() {
+    const { element: t, name: n, unresolvedKeyframes: i } = this;
+    if (!t || !t.current)
+      return;
+    const s = t.getValue(n);
+    s && s.jump(this.measuredOrigin, !1);
+    const a = i.length - 1, r = i[a];
+    i[a] = q[n](t.measureViewportBox(), window.getComputedStyle(t.current)), r !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = r), this.removedTransforms?.length && this.removedTransforms.forEach(([o, c]) => {
+      t.getValue(o).set(c);
+    }), this.resolveNoneKeyframes();
+  }
+}
+function zi(e, t, n) {
+  if (e == null)
+    return [];
+  if (e instanceof EventTarget)
+    return [e];
+  if (typeof e == "string") {
+    let i = document;
+    const s = n?.[e] ?? i.querySelectorAll(e);
+    return s ? Array.from(s) : [];
+  }
+  return Array.from(e).filter((i) => i != null);
+}
+const We = {
+  x: !1,
+  y: !1
+};
+function Nt() {
+  return We.x || We.y;
+}
+function Gt(e, t) {
+  const n = zi(e), i = new AbortController(), s = {
+    passive: !0,
+    ...t,
+    signal: i.signal
+  };
+  return [n, s, () => i.abort()];
+}
+function He(e) {
+  return !(e.pointerType === "touch" || Nt());
+}
+function qi(e, t, n = {}) {
+  const [i, s, a] = Gt(e, n), r = (o) => {
+    if (!He(o))
+      return;
+    const { target: c } = o, u = t(c, o);
+    if (typeof u != "function" || !c)
+      return;
+    const l = (f) => {
+      He(f) && (u(f), c.removeEventListener("pointerleave", l));
+    };
+    c.addEventListener("pointerleave", l, s);
+  };
+  return i.forEach((o) => {
+    o.addEventListener("pointerenter", r, s);
+  }), a;
+}
+const _t = (e, t) => t ? e === t ? !0 : _t(e, t.parentElement) : !1, $t = (e) => e.pointerType === "mouse" ? typeof e.button != "number" || e.button <= 0 : e.isPrimary !== !1, Xi = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function Yi(e) {
+  return Xi.has(e.tagName) || e.isContentEditable === !0;
+}
+const X = /* @__PURE__ */ new WeakSet();
+function je(e) {
+  return (t) => {
+    t.key === "Enter" && e(t);
+  };
+}
+function ae(e, t) {
+  e.dispatchEvent(new PointerEvent("pointer" + t, { isPrimary: !0, bubbles: !0 }));
+}
+const Zi = (e, t) => {
+  const n = e.currentTarget;
+  if (!n)
+    return;
+  const i = je(() => {
+    if (X.has(n))
+      return;
+    ae(n, "down");
+    const s = je(() => {
+      ae(n, "up");
+    }), a = () => ae(n, "cancel");
+    n.addEventListener("keyup", s, t), n.addEventListener("blur", a, t);
+  });
+  n.addEventListener("keydown", i, t), n.addEventListener("blur", () => n.removeEventListener("keydown", i), t);
+};
+function Ue(e) {
+  return $t(e) && !Nt();
+}
+function Ji(e, t, n = {}) {
+  const [i, s, a] = Gt(e, n), r = (o) => {
+    const c = o.currentTarget;
+    if (!Ue(o))
+      return;
+    X.add(c);
+    const u = t(c, o), l = (p, b) => {
+      window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", h), X.has(c) && X.delete(c), Ue(p) && typeof u == "function" && u(p, { success: b });
+    }, f = (p) => {
+      l(p, c === window || c === document || n.useGlobalTarget || _t(c, p.target));
+    }, h = (p) => {
+      l(p, !1);
+    };
+    window.addEventListener("pointerup", f, s), window.addEventListener("pointercancel", h, s);
+  };
+  return i.forEach((o) => {
+    (n.useGlobalTarget ? window : o).addEventListener("pointerdown", r, s), cn(o) && (o.addEventListener("focus", (u) => Zi(u, s)), !Yi(o) && !o.hasAttribute("tabindex") && (o.tabIndex = 0));
+  }), a;
+}
+class Wt extends un {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = Ui;
+  }
+  sortInstanceNodePosition(t, n) {
+    return t.compareDocumentPosition(n) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(t, n) {
+    const i = t.style;
+    return i ? i[n] : void 0;
+  }
+  removeValueFromRenderState(t, { vars: n, style: i }) {
+    delete n[t], delete i[t];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: t } = this.props;
+    ct(t) && (this.childSubscription = t.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+class W {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
+  }
+  update() {
+  }
+}
+function Qi({ top: e, left: t, right: n, bottom: i }) {
+  return {
+    x: { min: t, max: n },
+    y: { min: e, max: i }
+  };
+}
+function Es({ x: e, y: t }) {
+  return { top: t.min, right: e.max, bottom: t.max, left: e.min };
+}
+function es(e, t) {
+  if (!t)
+    return e;
+  const n = t({ x: e.left, y: e.top }), i = t({ x: e.right, y: e.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: i.y,
+    right: i.x
+  };
+}
+function re(e) {
+  return e === void 0 || e === 1;
+}
+function ts({ scale: e, scaleX: t, scaleY: n }) {
+  return !re(e) || !re(t) || !re(n);
+}
+function ns(e) {
+  return ts(e) || is(e) || e.z || e.rotate || e.rotateX || e.rotateY || e.skewX || e.skewY;
+}
+function is(e) {
+  return ze(e.x) || ze(e.y);
+}
+function ze(e) {
+  return e && e !== "0%";
+}
+function qe(e, t, n) {
+  const i = e - n, s = t * i;
+  return n + s;
+}
+function Xe(e, t, n, i, s) {
+  return s !== void 0 && (e = qe(e, s, i)), qe(e, n, i) + t;
+}
+function pe(e, t = 0, n = 1, i, s) {
+  e.min = Xe(e.min, t, n, i, s), e.max = Xe(e.max, t, n, i, s);
+}
+function ss(e, { x: t, y: n }) {
+  pe(e.x, t.translate, t.scale, t.originPoint), pe(e.y, n.translate, n.scale, n.originPoint);
+}
+const Ye = 0.999999999999, Ze = 1.0000000000001;
+function Ks(e, t, n, i = !1) {
+  const s = n.length;
+  if (!s)
+    return;
+  t.x = t.y = 1;
+  let a, r;
+  for (let o = 0; o < s; o++) {
+    a = n[o], r = a.projectionDelta;
+    const { visualElement: c } = a.options;
+    c && c.props.style && c.props.style.display === "contents" || (i && a.options.layoutScroll && a.scroll && a !== a.root && et(e, {
+      x: -a.scroll.offset.x,
+      y: -a.scroll.offset.y
+    }), r && (t.x *= r.x.scale, t.y *= r.y.scale, ss(e, r)), i && ns(a.latestValues) && et(e, a.latestValues));
+  }
+  t.x < Ze && t.x > Ye && (t.x = 1), t.y < Ze && t.y > Ye && (t.y = 1);
+}
+function Je(e, t) {
+  e.min = e.min + t, e.max = e.max + t;
+}
+function Qe(e, t, n, i, s = 0.5) {
+  const a = U(e.min, e.max, s);
+  pe(e, t, n, a, i);
+}
+function et(e, t) {
+  Qe(e.x, t.x, t.scaleX, t.scale, t.originX), Qe(e.y, t.y, t.scaleY, t.scale, t.originY);
+}
+function Ht(e, t) {
+  return Qi(es(e.getBoundingClientRect(), t));
+}
+function Rs(e, t, n) {
+  const i = Ht(e, n), { scroll: s } = t;
+  return s && (Je(i.x, s.offset.x), Je(i.y, s.offset.y)), i;
+}
+function jt(e, { style: t, vars: n }, i, s) {
+  const a = e.style;
+  let r;
+  for (r in t)
+    a[r] = t[r];
+  s?.applyProjectionStyles(a, i);
+  for (r in n)
+    a.setProperty(r, n[r]);
+}
+function as(e) {
+  return window.getComputedStyle(e);
+}
+class rs extends Wt {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = jt;
+  }
+  readValueFromInstance(t, n) {
+    if (Te.has(n))
+      return this.projection?.isProjecting ? fn(n) : hn(t, n);
+    {
+      const i = as(t), s = (dn(n) ? i.getPropertyValue(n) : i[n]) || 0;
+      return typeof s == "string" ? s.trim() : s;
+    }
+  }
+  measureInstanceViewportBox(t, { transformPagePoint: n }) {
+    return Ht(t, n);
+  }
+  build(t, n, i) {
+    mn(t, n, i.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(t, n, i) {
+    return pn(t, n, i);
+  }
+}
+const Ut = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+function os(e, t, n, i) {
+  jt(e, t, void 0, i);
+  for (const s in t.attrs)
+    e.setAttribute(Ut.has(s) ? s : ut(s), t.attrs[s]);
+}
+class ls extends Wt {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = yn;
+  }
+  getBaseTargetFromProps(t, n) {
+    return t[n];
+  }
+  readValueFromInstance(t, n) {
+    if (Te.has(n)) {
+      const i = gn(n);
+      return i && i.default || 0;
+    }
+    return n = Ut.has(n) ? n : ut(n), t.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(t, n, i) {
+    return Tn(t, n, i);
+  }
+  build(t, n, i) {
+    bn(t, n, this.isSVGTag, i.transformTemplate, i.style);
+  }
+  renderInstance(t, n, i, s) {
+    os(t, n, i, s);
+  }
+  mount(t) {
+    this.isSVGTag = vn(t.tagName), super.mount(t);
+  }
+}
+const cs = ht.length;
+function zt(e) {
+  if (!e)
+    return;
+  if (!e.isControllingVariants) {
+    const n = e.parent ? zt(e.parent) || {} : {};
+    return e.props.initial !== void 0 && (n.initial = e.props.initial), n;
+  }
+  const t = {};
+  for (let n = 0; n < cs; n++) {
+    const i = ht[n], s = e.props[i];
+    (ft(s) || s === !1) && (t[i] = s);
+  }
+  return t;
+}
+function qt(e, t) {
+  if (!Array.isArray(t))
+    return !1;
+  const n = t.length;
+  if (n !== e.length)
+    return !1;
+  for (let i = 0; i < n; i++)
+    if (t[i] !== e[i])
+      return !1;
+  return !0;
+}
+const us = [...mt].reverse(), fs = mt.length;
+function hs(e) {
+  return (t) => Promise.all(t.map(({ animation: n, options: i }) => $i(e, n, i)));
+}
+function ds(e) {
+  let t = hs(e), n = tt(), i = !0;
+  const s = (c) => (u, l) => {
+    const f = L(e, l, c === "exit" ? e.presenceContext?.custom : void 0);
+    if (f) {
+      const { transition: h, transitionEnd: p, ...b } = f;
+      u = { ...u, ...b, ...p };
+    }
+    return u;
+  };
+  function a(c) {
+    t = c(e);
+  }
+  function r(c) {
+    const { props: u } = e, l = zt(e.parent) || {}, f = [], h = /* @__PURE__ */ new Set();
+    let p = {}, b = 1 / 0;
+    for (let T = 0; T < fs; T++) {
+      const d = us[T], v = n[d], x = u[d] !== void 0 ? u[d] : l[d], M = ft(x), m = d === c ? v.isActive : null;
+      m === !1 && (b = T);
+      let A = x === l[d] && x !== u[d] && M;
+      if (A && i && e.manuallyAnimateOnMount && (A = !1), v.protectedKeys = { ...p }, // If it isn't active and hasn't *just* been set as inactive
+      !v.isActive && m === null || // If we didn't and don't have any defined prop for this animation type
+      !x && !v.prevProp || // Or if the prop doesn't define an animation
+      dt(x) || typeof x == "boolean")
+        continue;
+      const S = ms(v.prevProp, x);
+      let y = S || // If we're making this variant active, we want to always make it active
+      d === c && v.isActive && !A && M || // If we removed a higher-priority variant (i is in reverse order)
+      T > b && M, D = !1;
+      const C = Array.isArray(x) ? x : [x];
+      let K = C.reduce(s(d), {});
+      m === !1 && (K = {});
+      const { prevResolvedValues: Ce = {} } = v, Xt = {
+        ...Ce,
+        ...K
+      }, Pe = (V) => {
+        y = !0, h.has(V) && (D = !0, h.delete(V)), v.needsAnimating[V] = !0;
+        const P = e.getValue(V);
+        P && (P.liveStyle = !1);
+      };
+      for (const V in Xt) {
+        const P = K[V], I = Ce[V];
+        if (p.hasOwnProperty(V))
+          continue;
+        let R = !1;
+        de(P) && de(I) ? R = !qt(P, I) : R = P !== I, R ? P != null ? Pe(V) : h.add(V) : P !== void 0 && h.has(V) ? Pe(V) : v.protectedKeys[V] = !0;
+      }
+      v.prevProp = x, v.prevResolvedValues = K, v.isActive && (p = { ...p, ...K }), i && e.blockInitialAnimation && (y = !1);
+      const ke = A && S;
+      y && (!ke || D) && f.push(...C.map((V) => {
+        const P = { type: d };
+        if (typeof V == "string" && i && !ke && e.manuallyAnimateOnMount && e.parent) {
+          const { parent: I } = e, R = L(I, V);
+          if (I.enteringChildren && R) {
+            const { delayChildren: Yt } = R.transition || {};
+            P.delay = Et(I.enteringChildren, e, Yt);
+          }
+        }
+        return {
+          animation: V,
+          options: P
+        };
+      }));
+    }
+    if (h.size) {
+      const T = {};
+      if (typeof u.initial != "boolean") {
+        const d = L(e, Array.isArray(u.initial) ? u.initial[0] : u.initial);
+        d && d.transition && (T.transition = d.transition);
+      }
+      h.forEach((d) => {
+        const v = e.getBaseTarget(d), x = e.getValue(d);
+        x && (x.liveStyle = !0), T[d] = v ?? null;
+      }), f.push({ animation: T });
+    }
+    let g = !!f.length;
+    return i && (u.initial === !1 || u.initial === u.animate) && !e.manuallyAnimateOnMount && (g = !1), i = !1, g ? t(f) : Promise.resolve();
+  }
+  function o(c, u) {
+    if (n[c].isActive === u)
+      return Promise.resolve();
+    e.variantChildren?.forEach((f) => f.animationState?.setActive(c, u)), n[c].isActive = u;
+    const l = r(c);
+    for (const f in n)
+      n[f].protectedKeys = {};
+    return l;
+  }
+  return {
+    animateChanges: r,
+    setActive: o,
+    setAnimateFunction: a,
+    getState: () => n,
+    reset: () => {
+      n = tt();
+    }
+  };
+}
+function ms(e, t) {
+  return typeof t == "string" ? t !== e : Array.isArray(t) ? !qt(t, e) : !1;
+}
+function E(e = !1) {
+  return {
+    isActive: e,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function tt() {
+  return {
+    animate: E(!0),
+    whileInView: E(),
+    whileHover: E(),
+    whileTap: E(),
+    whileDrag: E(),
+    whileFocus: E(),
+    exit: E()
+  };
+}
+function nt(e, t, n, i = { passive: !0 }) {
+  return e.addEventListener(t, n, i), () => e.removeEventListener(t, n);
+}
+const ps = (e, t) => t.isSVG ?? xn(e) ? new ls(t) : new rs(t, {
+  allowProjection: e !== An
+});
+class ys 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(t) {
+    super(t), t.animationState || (t.animationState = ds(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    dt(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    t !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    this.node.animationState.reset(), this.unmountControls?.();
+  }
+}
+let gs = 0;
+class Ts extends W {
+  constructor() {
+    super(...arguments), this.id = gs++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: t, onExitComplete: n } = this.node.presenceContext, { isPresent: i } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === i)
+      return;
+    const s = this.node.animationState.setActive("exit", !t);
+    n && !t && s.then(() => {
+      n(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: n } = this.node.presenceContext || {};
+    n && n(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+const bs = {
+  animation: {
+    Feature: ys
+  },
+  exit: {
+    Feature: Ts
+  }
+};
+function Me(e) {
+  return {
+    point: {
+      x: e.pageX,
+      y: e.pageY
+    }
+  };
+}
+const Bs = (e) => (t) => $t(t) && e(t, Me(t));
+function it(e, t, n) {
+  const { props: i } = e;
+  e.animationState && i.whileHover && e.animationState.setActive("whileHover", n === "Start");
+  const s = "onHover" + n, a = i[s];
+  a && G.postRender(() => a(t, Me(t)));
+}
+class vs extends W {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = qi(t, (n, i) => (it(this.node, i, "Start"), (s) => it(this.node, s, "End"))));
+  }
+  unmount() {
+  }
+}
+class xs extends W {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.node.current.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    !t || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = ee(nt(this.node.current, "focus", () => this.onFocus()), nt(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+function st(e, t, n) {
+  const { props: i } = e;
+  if (e.current instanceof HTMLButtonElement && e.current.disabled)
+    return;
+  e.animationState && i.whileTap && e.animationState.setActive("whileTap", n === "Start");
+  const s = "onTap" + (n === "End" ? "" : n), a = i[s];
+  a && G.postRender(() => a(t, Me(t)));
+}
+class As extends W {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = Ji(t, (n, i) => (st(this.node, i, "Start"), (s, { success: a }) => st(this.node, s, a ? "End" : "Cancel")), { useGlobalTarget: this.node.props.globalTapTarget }));
+  }
+  unmount() {
+  }
+}
+const ye = /* @__PURE__ */ new WeakMap(), oe = /* @__PURE__ */ new WeakMap(), ws = (e) => {
+  const t = ye.get(e.target);
+  t && t(e);
+}, Ss = (e) => {
+  e.forEach(ws);
+};
+function Vs({ root: e, ...t }) {
+  const n = e || document;
+  oe.has(n) || oe.set(n, {});
+  const i = oe.get(n), s = JSON.stringify(t);
+  return i[s] || (i[s] = new IntersectionObserver(Ss, { root: e, ...t })), i[s];
+}
+function Ds(e, t, n) {
+  const i = Vs(t);
+  return ye.set(e, n), i.observe(e), () => {
+    ye.delete(e), i.unobserve(e);
+  };
+}
+const Ms = {
+  some: 0,
+  all: 1
+};
+class Cs extends W {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: t = {} } = this.node.getProps(), { root: n, margin: i, amount: s = "some", once: a } = t, r = {
+      root: n ? n.current : void 0,
+      rootMargin: i,
+      threshold: typeof s == "number" ? s : Ms[s]
+    }, o = (c) => {
+      const { isIntersecting: u } = c;
+      if (this.isInView === u || (this.isInView = u, a && !u && this.hasEnteredView))
+        return;
+      u && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", u);
+      const { onViewportEnter: l, onViewportLeave: f } = this.node.getProps(), h = u ? l : f;
+      h && h(c);
+    };
+    return Ds(this.node.current, r, o);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: t, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(Ps(t, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function Ps({ viewport: e = {} }, { viewport: t = {} } = {}) {
+  return (n) => e[n] !== t[n];
+}
+const ks = {
+  inView: {
+    Feature: Cs
+  },
+  tap: {
+    Feature: As
+  },
+  focus: {
+    Feature: xs
+  },
+  hover: {
+    Feature: vs
+  }
+}, Ls = {
+  renderer: ps,
+  ...bs,
+  ...ks
+};
+export {
+  Zn as $,
+  Yi as A,
+  bs as B,
+  $i as C,
+  xi as D,
+  mi as E,
+  W as F,
+  Et as G,
+  Kt as H,
+  wi as I,
+  De as J,
+  Pi as K,
+  Fi as L,
+  Oi as M,
+  fi as N,
+  he as O,
+  Lt as P,
+  me as Q,
+  fe as R,
+  ei as S,
+  B as T,
+  J as U,
+  we as V,
+  Z as W,
+  _n as X,
+  Ot as Y,
+  Ui as Z,
+  Jn as _,
+  Ii as a,
+  Be as a$,
+  Qn as a0,
+  H as a1,
+  Ft as a2,
+  _e as a3,
+  ci as a4,
+  bi as a5,
+  ui as a6,
+  Mt as a7,
+  Nt as a8,
+  qi as a9,
+  ds as aA,
+  zt as aB,
+  L as aC,
+  Ri as aD,
+  es as aE,
+  pe as aF,
+  Xe as aG,
+  Qe as aH,
+  Ht as aI,
+  jt as aJ,
+  Ut as aK,
+  os as aL,
+  be as aM,
+  xt as aN,
+  ve as aO,
+  vt as aP,
+  bt as aQ,
+  xe as aR,
+  At as aS,
+  z as aT,
+  Cn as aU,
+  wt as aV,
+  Pn as aW,
+  gt as aX,
+  Tt as aY,
+  St as aZ,
+  kn as a_,
+  Ji as aa,
+  _t as ab,
+  ai as ac,
+  de as ad,
+  Bt as ae,
+  Yn as af,
+  Dt as ag,
+  Ne as ah,
+  ne as ai,
+  Ae as aj,
+  Vt as ak,
+  Nn as al,
+  Bn as am,
+  Y as an,
+  ce as ao,
+  Kn as ap,
+  zi as aq,
+  oi as ar,
+  kt as as,
+  ri as at,
+  On as au,
+  Bi as av,
+  Wt as aw,
+  rs as ax,
+  ls as ay,
+  ms as az,
+  et as b,
+  Mn as c,
+  Ls as d,
+  ts as e,
+  ss as f,
+  Rt as g,
+  ns as h,
+  We as i,
+  is as j,
+  Ks as k,
+  Ni as l,
+  nt as m,
+  Bs as n,
+  $t as o,
+  pt as p,
+  Me as q,
+  ee as r,
+  qe as s,
+  Je as t,
+  F as u,
+  k as v,
+  Rs as w,
+  Es as x,
+  Qi as y,
+  Li as z
+};