lizaui 3.0.35 → 3.0.36

package/dist/chunks/ripple-BQsLJHrx.js

@@ -0,0 +1,3594 @@
+import "./assertion-CrT8p68K.js";
+import * as he from "react";
+import { useState as Vt, useCallback as St, createContext as et, useRef as B, useLayoutEffect as qs, useEffect as Rt, useId as pe, useContext as E, useInsertionEffect as In, useMemo as Y, Children as Zs, isValidElement as Js, forwardRef as Qs, Fragment as kn, createElement as ti } from "react";
+import { j as O } from "./jsx-runtime-BYq8_R6m.js";
+function ei(t, e, n) {
+  return Math.min(Math.max(t, e), n);
+}
+function ni(t) {
+  return `${t}-${Math.floor(Math.random() * 1e6)}`;
+}
+function tc(t = {}) {
+  const [e, n] = Vt([]), s = St((r) => {
+    const o = r.target, a = Math.max(o.clientWidth, o.clientHeight);
+    n((u) => [
+      ...u,
+      {
+        key: ni(u.length.toString()),
+        size: a,
+        x: r.x - a / 2,
+        y: r.y - a / 2
+      }
+    ]);
+  }, []), i = St((r) => {
+    n((o) => o.filter((a) => a.key !== r));
+  }, []);
+  return { ripples: e, onClear: i, onPress: s, ...t };
+}
+const Nn = et({});
+function me(t) {
+  const e = B(null);
+  return e.current === null && (e.current = t()), e.current;
+}
+const ge = typeof window < "u", Ln = ge ? qs : Rt, Et = /* @__PURE__ */ et(null);
+function si(t, e) {
+  t.indexOf(e) === -1 && t.push(e);
+}
+function ii(t, e) {
+  const n = t.indexOf(e);
+  n > -1 && t.splice(n, 1);
+}
+const X = (t, e, n) => n > e ? e : n < t ? t : n;
+let nt = () => {
+}, W = () => {
+};
+process.env.NODE_ENV !== "production" && (nt = (t, e) => {
+}, W = (t, e) => {
+  if (!t)
+    throw new Error(e);
+});
+const j = {}, Bn = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t);
+function ri(t) {
+  return typeof t == "object" && t !== null;
+}
+const Kn = (t) => /^0[^.\s]+$/u.test(t);
+// @__NO_SIDE_EFFECTS__
+function ye(t) {
+  let e;
+  return () => (e === void 0 && (e = t()), e);
+}
+const st = /* @__NO_SIDE_EFFECTS__ */ (t) => t, oi = (t, e) => (n) => e(t(n)), Ot = (...t) => t.reduce(oi), jn = /* @__NO_SIDE_EFFECTS__ */ (t, e, n) => {
+  const s = e - t;
+  return s === 0 ? 1 : (n - t) / s;
+};
+class $n {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(e) {
+    return si(this.subscriptions, e), () => ii(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 N = /* @__NO_SIDE_EFFECTS__ */ (t) => t * 1e3, K = /* @__NO_SIDE_EFFECTS__ */ (t) => t / 1e3;
+function Wn(t, e) {
+  return e ? t * (1e3 / e) : 0;
+}
+const Ge = /* @__PURE__ */ new Set();
+function be(t, e, n) {
+  t || Ge.has(e) || Ge.add(e);
+}
+const _n = (t, e, n) => (((1 - 3 * n + 3 * e) * t + (3 * n - 6 * e)) * t + 3 * e) * t, ai = 1e-7, ci = 12;
+function ui(t, e, n, s, i) {
+  let r, o, a = 0;
+  do
+    o = e + (n - e) / 2, r = _n(o, s, i) - t, r > 0 ? n = o : e = o;
+  while (Math.abs(r) > ai && ++a < ci);
+  return o;
+}
+function mt(t, e, n, s) {
+  if (t === e && n === s)
+    return st;
+  const i = (r) => ui(r, 0, 1, t, n);
+  return (r) => r === 0 || r === 1 ? r : _n(i(r), e, s);
+}
+const zn = (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, Un = (t) => (e) => 1 - t(1 - e), Gn = /* @__PURE__ */ mt(0.33, 1.53, 0.69, 0.99), Te = /* @__PURE__ */ Un(Gn), Hn = /* @__PURE__ */ zn(Te), Yn = (t) => (t *= 2) < 1 ? 0.5 * Te(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), ve = (t) => 1 - Math.sin(Math.acos(t)), li = Un(ve), Xn = zn(ve), fi = /* @__PURE__ */ mt(0.42, 0, 1, 1), di = /* @__PURE__ */ mt(0, 0, 0.58, 1), qn = /* @__PURE__ */ mt(0.42, 0, 0.58, 1), hi = (t) => Array.isArray(t) && typeof t[0] != "number", Zn = (t) => Array.isArray(t) && typeof t[0] == "number", He = {
+  linear: st,
+  easeIn: fi,
+  easeInOut: qn,
+  easeOut: di,
+  circIn: ve,
+  circInOut: Xn,
+  circOut: li,
+  backIn: Te,
+  backInOut: Hn,
+  backOut: Gn,
+  anticipate: Yn
+}, pi = (t) => typeof t == "string", Ye = (t) => {
+  if (Zn(t)) {
+    W(t.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [e, n, s, i] = t;
+    return mt(e, n, s, i);
+  } else if (pi(t))
+    return W(He[t] !== void 0, `Invalid easing type '${t}'`), He[t];
+  return t;
+}, bt = [
+  "setup",
+  // Compute
+  "read",
+  // Read
+  "resolveKeyframes",
+  // Write/Read/Write/Read
+  "preUpdate",
+  // Compute
+  "update",
+  // Compute
+  "preRender",
+  // Compute
+  "render",
+  // Write
+  "postRender"
+  // Compute
+];
+function mi(t, e) {
+  let n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), i = !1, r = !1;
+  const o = /* @__PURE__ */ new WeakSet();
+  let a = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  };
+  function u(c) {
+    o.has(c) && (l.schedule(c), t()), c(a);
+  }
+  const l = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (c, f = !1, d = !1) => {
+      const g = d && i ? n : s;
+      return f && o.add(c), g.has(c) || g.add(c), c;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (c) => {
+      s.delete(c), o.delete(c);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (c) => {
+      if (a = c, i) {
+        r = !0;
+        return;
+      }
+      i = !0, [n, s] = [s, n], n.forEach(u), n.clear(), i = !1, r && (r = !1, l.process(c));
+    }
+  };
+  return l;
+}
+const gi = 40;
+function Jn(t, e) {
+  let n = !1, s = !0;
+  const i = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, r = () => n = !0, o = bt.reduce((y, S) => (y[S] = mi(r), y), {}), { setup: a, read: u, resolveKeyframes: l, preUpdate: c, update: f, preRender: d, render: h, postRender: g } = o, T = () => {
+    const y = j.useManualTiming ? i.timestamp : performance.now();
+    n = !1, j.useManualTiming || (i.delta = s ? 1e3 / 60 : Math.max(Math.min(y - i.timestamp, gi), 1)), i.timestamp = y, i.isProcessing = !0, a.process(i), u.process(i), l.process(i), c.process(i), f.process(i), d.process(i), h.process(i), g.process(i), i.isProcessing = !1, n && e && (s = !1, t(T));
+  }, w = () => {
+    n = !0, s = !0, i.isProcessing || t(T);
+  };
+  return { schedule: bt.reduce((y, S) => {
+    const m = o[S];
+    return y[S] = (v, A = !1, x = !1) => (n || w(), m.schedule(v, A, x)), y;
+  }, {}), cancel: (y) => {
+    for (let S = 0; S < bt.length; S++)
+      o[bt[S]].cancel(y);
+  }, state: i, steps: o };
+}
+const { schedule: k, cancel: Ht, state: At, steps: ec } = /* @__PURE__ */ Jn(typeof requestAnimationFrame < "u" ? requestAnimationFrame : st, !0);
+let wt;
+function yi() {
+  wt = void 0;
+}
+const I = {
+  now: () => (wt === void 0 && I.set(At.isProcessing || j.useManualTiming ? At.timestamp : performance.now()), wt),
+  set: (t) => {
+    wt = t, queueMicrotask(yi);
+  }
+}, Qn = (t) => (e) => typeof e == "string" && e.startsWith(t), we = /* @__PURE__ */ Qn("--"), bi = /* @__PURE__ */ Qn("var(--"), xe = (t) => bi(t) ? Ti.test(t.split("/*")[0].trim()) : !1, Ti = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu, it = {
+  test: (t) => typeof t == "number",
+  parse: parseFloat,
+  transform: (t) => t
+}, ft = {
+  ...it,
+  transform: (t) => X(0, 1, t)
+}, Tt = {
+  ...it,
+  default: 1
+}, lt = (t) => Math.round(t * 1e5) / 1e5, Ve = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function vi(t) {
+  return t == null;
+}
+const wi = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, Se = (t, e) => (n) => !!(typeof n == "string" && wi.test(n) && n.startsWith(t) || e && !vi(n) && Object.prototype.hasOwnProperty.call(n, e)), ts = (t, e, n) => (s) => {
+  if (typeof s != "string")
+    return s;
+  const [i, r, o, a] = s.match(Ve);
+  return {
+    [t]: parseFloat(i),
+    [e]: parseFloat(r),
+    [n]: parseFloat(o),
+    alpha: a !== void 0 ? parseFloat(a) : 1
+  };
+}, xi = (t) => X(0, 255, t), Kt = {
+  ...it,
+  transform: (t) => Math.round(xi(t))
+}, z = {
+  test: /* @__PURE__ */ Se("rgb", "red"),
+  parse: /* @__PURE__ */ ts("red", "green", "blue"),
+  transform: ({ red: t, green: e, blue: n, alpha: s = 1 }) => "rgba(" + Kt.transform(t) + ", " + Kt.transform(e) + ", " + Kt.transform(n) + ", " + lt(ft.transform(s)) + ")"
+};
+function Vi(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 Yt = {
+  test: /* @__PURE__ */ Se("#"),
+  parse: Vi,
+  transform: z.transform
+}, gt = /* @__NO_SIDE_EFFECTS__ */ (t) => ({
+  test: (e) => typeof e == "string" && e.endsWith(t) && e.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (e) => `${e}${t}`
+}), $ = /* @__PURE__ */ gt("deg"), Q = /* @__PURE__ */ gt("%"), b = /* @__PURE__ */ gt("px"), Si = /* @__PURE__ */ gt("vh"), Ai = /* @__PURE__ */ gt("vw"), Xe = {
+  ...Q,
+  parse: (t) => Q.parse(t) / 100,
+  transform: (t) => Q.transform(t * 100)
+}, Z = {
+  test: /* @__PURE__ */ Se("hsl", "hue"),
+  parse: /* @__PURE__ */ ts("hue", "saturation", "lightness"),
+  transform: ({ hue: t, saturation: e, lightness: n, alpha: s = 1 }) => "hsla(" + Math.round(t) + ", " + Q.transform(lt(e)) + ", " + Q.transform(lt(n)) + ", " + lt(ft.transform(s)) + ")"
+}, C = {
+  test: (t) => z.test(t) || Yt.test(t) || Z.test(t),
+  parse: (t) => z.test(t) ? z.parse(t) : Z.test(t) ? Z.parse(t) : Yt.parse(t),
+  transform: (t) => typeof t == "string" ? t : t.hasOwnProperty("red") ? z.transform(t) : Z.transform(t),
+  getAnimatableNone: (t) => {
+    const e = C.parse(t);
+    return e.alpha = 0, C.transform(e);
+  }
+}, Mi = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+function Ci(t) {
+  var e, n;
+  return isNaN(t) && typeof t == "string" && (((e = t.match(Ve)) == null ? void 0 : e.length) || 0) + (((n = t.match(Mi)) == null ? void 0 : n.length) || 0) > 0;
+}
+const es = "number", ns = "color", Pi = "var", Di = "var(", qe = "${}", Fi = /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 dt(t) {
+  const e = t.toString(), n = [], s = {
+    color: [],
+    number: [],
+    var: []
+  }, i = [];
+  let r = 0;
+  const a = e.replace(Fi, (u) => (C.test(u) ? (s.color.push(r), i.push(ns), n.push(C.parse(u))) : u.startsWith(Di) ? (s.var.push(r), i.push(Pi), n.push(u)) : (s.number.push(r), i.push(es), n.push(parseFloat(u))), ++r, qe)).split(qe);
+  return { values: n, split: a, indexes: s, types: i };
+}
+function ss(t) {
+  return dt(t).values;
+}
+function is(t) {
+  const { split: e, types: n } = dt(t), s = e.length;
+  return (i) => {
+    let r = "";
+    for (let o = 0; o < s; o++)
+      if (r += e[o], i[o] !== void 0) {
+        const a = n[o];
+        a === es ? r += lt(i[o]) : a === ns ? r += C.transform(i[o]) : r += i[o];
+      }
+    return r;
+  };
+}
+const Ri = (t) => typeof t == "number" ? 0 : C.test(t) ? C.getAnimatableNone(t) : t;
+function Ei(t) {
+  const e = ss(t);
+  return is(t)(e.map(Ri));
+}
+const rt = {
+  test: Ci,
+  parse: ss,
+  createTransformer: is,
+  getAnimatableNone: Ei
+};
+function jt(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 Oi({ 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 a = n < 0.5 ? n * (1 + e) : n + e - n * e, u = 2 * n - a;
+    i = jt(u, a, t + 1 / 3), r = jt(u, a, t), o = jt(u, a, t - 1 / 3);
+  }
+  return {
+    red: Math.round(i * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(o * 255),
+    alpha: s
+  };
+}
+function Mt(t, e) {
+  return (n) => n > 0 ? e : t;
+}
+const yt = (t, e, n) => t + (e - t) * n, $t = (t, e, n) => {
+  const s = t * t, i = n * (e * e - s) + s;
+  return i < 0 ? 0 : Math.sqrt(i);
+}, Ii = [Yt, z, Z], ki = (t) => Ii.find((e) => e.test(t));
+function Ze(t) {
+  const e = ki(t);
+  if (nt(!!e, `'${t}' is not an animatable color. Use the equivalent color code instead.`), !e)
+    return !1;
+  let n = e.parse(t);
+  return e === Z && (n = Oi(n)), n;
+}
+const Je = (t, e) => {
+  const n = Ze(t), s = Ze(e);
+  if (!n || !s)
+    return Mt(t, e);
+  const i = { ...n };
+  return (r) => (i.red = $t(n.red, s.red, r), i.green = $t(n.green, s.green, r), i.blue = $t(n.blue, s.blue, r), i.alpha = yt(n.alpha, s.alpha, r), z.transform(i));
+}, Xt = /* @__PURE__ */ new Set(["none", "hidden"]);
+function Ni(t, e) {
+  return Xt.has(t) ? (n) => n <= 0 ? t : e : (n) => n >= 1 ? e : t;
+}
+function Li(t, e) {
+  return (n) => yt(t, e, n);
+}
+function Ae(t) {
+  return typeof t == "number" ? Li : typeof t == "string" ? xe(t) ? Mt : C.test(t) ? Je : ji : Array.isArray(t) ? rs : typeof t == "object" ? C.test(t) ? Je : Bi : Mt;
+}
+function rs(t, e) {
+  const n = [...t], s = n.length, i = t.map((r, o) => Ae(r)(r, e[o]));
+  return (r) => {
+    for (let o = 0; o < s; o++)
+      n[o] = i[o](r);
+    return n;
+  };
+}
+function Bi(t, e) {
+  const n = { ...t, ...e }, s = {};
+  for (const i in n)
+    t[i] !== void 0 && e[i] !== void 0 && (s[i] = Ae(t[i])(t[i], e[i]));
+  return (i) => {
+    for (const r in s)
+      n[r] = s[r](i);
+    return n;
+  };
+}
+function Ki(t, e) {
+  const n = [], s = { color: 0, var: 0, number: 0 };
+  for (let i = 0; i < e.values.length; i++) {
+    const r = e.types[i], o = t.indexes[r][s[r]], a = t.values[o] ?? 0;
+    n[i] = a, s[r]++;
+  }
+  return n;
+}
+const ji = (t, e) => {
+  const n = rt.createTransformer(e), s = dt(t), i = dt(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 ? Xt.has(t) && !i.values.length || Xt.has(e) && !s.values.length ? Ni(t, e) : Ot(rs(Ki(s, i), i.values), n) : (nt(!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.`), Mt(t, e));
+};
+function os(t, e, n) {
+  return typeof t == "number" && typeof e == "number" && typeof n == "number" ? yt(t, e, n) : Ae(t)(t, e);
+}
+const $i = (t) => {
+  const e = ({ timestamp: n }) => t(n);
+  return {
+    start: (n = !0) => k.update(e, n),
+    stop: () => Ht(e),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => At.isProcessing ? At.timestamp : I.now()
+  };
+}, as = (t, e, n = 10) => {
+  let s = "";
+  const i = Math.max(Math.round(e / n), 2);
+  for (let r = 0; r < i; r++)
+    s += Math.round(t(r / (i - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${s.substring(0, s.length - 2)})`;
+}, Ct = 2e4;
+function Me(t) {
+  let e = 0;
+  const n = 50;
+  let s = t.next(e);
+  for (; !s.done && e < Ct; )
+    e += n, s = t.next(e);
+  return e >= Ct ? 1 / 0 : e;
+}
+function Wi(t, e = 100, n) {
+  const s = n({ ...t, keyframes: [0, e] }), i = Math.min(Me(s), Ct);
+  return {
+    type: "keyframes",
+    ease: (r) => s.next(i * r).value / e,
+    duration: /* @__PURE__ */ K(i)
+  };
+}
+const _i = 5;
+function cs(t, e, n) {
+  const s = Math.max(e - _i, 0);
+  return Wn(n - t(s), e - s);
+}
+const M = {
+  // 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
+}, Wt = 1e-3;
+function zi({ duration: t = M.duration, bounce: e = M.bounce, velocity: n = M.velocity, mass: s = M.mass }) {
+  let i, r;
+  nt(t <= /* @__PURE__ */ N(M.maxDuration), "Spring duration must be 10 seconds or less");
+  let o = 1 - e;
+  o = X(M.minDamping, M.maxDamping, o), t = X(M.minDuration, M.maxDuration, /* @__PURE__ */ K(t)), o < 1 ? (i = (l) => {
+    const c = l * o, f = c * t, d = c - n, h = qt(l, o), g = Math.exp(-f);
+    return Wt - d / h * g;
+  }, r = (l) => {
+    const f = l * o * t, d = f * n + n, h = Math.pow(o, 2) * Math.pow(l, 2) * t, g = Math.exp(-f), T = qt(Math.pow(l, 2), o);
+    return (-i(l) + Wt > 0 ? -1 : 1) * ((d - h) * g) / T;
+  }) : (i = (l) => {
+    const c = Math.exp(-l * t), f = (l - n) * t + 1;
+    return -Wt + c * f;
+  }, r = (l) => {
+    const c = Math.exp(-l * t), f = (n - l) * (t * t);
+    return c * f;
+  });
+  const a = 5 / t, u = Gi(i, r, a);
+  if (t = /* @__PURE__ */ N(t), isNaN(u))
+    return {
+      stiffness: M.stiffness,
+      damping: M.damping,
+      duration: t
+    };
+  {
+    const l = Math.pow(u, 2) * s;
+    return {
+      stiffness: l,
+      damping: o * 2 * Math.sqrt(s * l),
+      duration: t
+    };
+  }
+}
+const Ui = 12;
+function Gi(t, e, n) {
+  let s = n;
+  for (let i = 1; i < Ui; i++)
+    s = s - t(s) / e(s);
+  return s;
+}
+function qt(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const Hi = ["duration", "bounce"], Yi = ["stiffness", "damping", "mass"];
+function Qe(t, e) {
+  return e.some((n) => t[n] !== void 0);
+}
+function Xi(t) {
+  let e = {
+    velocity: M.velocity,
+    stiffness: M.stiffness,
+    damping: M.damping,
+    mass: M.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!Qe(t, Yi) && Qe(t, Hi))
+    if (t.visualDuration) {
+      const n = t.visualDuration, s = 2 * Math.PI / (n * 1.2), i = s * s, r = 2 * X(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(i);
+      e = {
+        ...e,
+        mass: M.mass,
+        stiffness: i,
+        damping: r
+      };
+    } else {
+      const n = zi(t);
+      e = {
+        ...e,
+        ...n,
+        mass: M.mass
+      }, e.isResolvedFromDuration = !0;
+    }
+  return e;
+}
+function Pt(t = M.visualDuration, e = M.bounce) {
+  const n = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: e
+  } : t;
+  let { restSpeed: s, restDelta: i } = n;
+  const r = n.keyframes[0], o = n.keyframes[n.keyframes.length - 1], a = { done: !1, value: r }, { stiffness: u, damping: l, mass: c, duration: f, velocity: d, isResolvedFromDuration: h } = Xi({
+    ...n,
+    velocity: -/* @__PURE__ */ K(n.velocity || 0)
+  }), g = d || 0, T = l / (2 * Math.sqrt(u * c)), w = o - r, p = /* @__PURE__ */ K(Math.sqrt(u / c)), V = Math.abs(w) < 5;
+  s || (s = V ? M.restSpeed.granular : M.restSpeed.default), i || (i = V ? M.restDelta.granular : M.restDelta.default);
+  let y;
+  if (T < 1) {
+    const m = qt(p, T);
+    y = (v) => {
+      const A = Math.exp(-T * p * v);
+      return o - A * ((g + T * p * w) / m * Math.sin(m * v) + w * Math.cos(m * v));
+    };
+  } else if (T === 1)
+    y = (m) => o - Math.exp(-p * m) * (w + (g + p * w) * m);
+  else {
+    const m = p * Math.sqrt(T * T - 1);
+    y = (v) => {
+      const A = Math.exp(-T * p * v), x = Math.min(m * v, 300);
+      return o - A * ((g + T * p * w) * Math.sinh(x) + m * w * Math.cosh(x)) / m;
+    };
+  }
+  const S = {
+    calculatedDuration: h && f || null,
+    next: (m) => {
+      const v = y(m);
+      if (h)
+        a.done = m >= f;
+      else {
+        let A = m === 0 ? g : 0;
+        T < 1 && (A = m === 0 ? /* @__PURE__ */ N(g) : cs(y, m, v));
+        const x = Math.abs(A) <= s, P = Math.abs(o - v) <= i;
+        a.done = x && P;
+      }
+      return a.value = a.done ? o : v, a;
+    },
+    toString: () => {
+      const m = Math.min(Me(S), Ct), v = as((A) => S.next(m * A).value, m, 30);
+      return m + "ms " + v;
+    },
+    toTransition: () => {
+    }
+  };
+  return S;
+}
+Pt.applyToOptions = (t) => {
+  const e = Wi(t, 100, Pt);
+  return t.ease = e.ease, t.duration = /* @__PURE__ */ N(e.duration), t.type = "keyframes", t;
+};
+function Zt({ keyframes: t, velocity: e = 0, power: n = 0.8, timeConstant: s = 325, bounceDamping: i = 10, bounceStiffness: r = 500, modifyTarget: o, min: a, max: u, restDelta: l = 0.5, restSpeed: c }) {
+  const f = t[0], d = {
+    done: !1,
+    value: f
+  }, h = (x) => a !== void 0 && x < a || u !== void 0 && x > u, g = (x) => a === void 0 ? u : u === void 0 || Math.abs(a - x) < Math.abs(u - x) ? a : u;
+  let T = n * e;
+  const w = f + T, p = o === void 0 ? w : o(w);
+  p !== w && (T = p - f);
+  const V = (x) => -T * Math.exp(-x / s), y = (x) => p + V(x), S = (x) => {
+    const P = V(x), R = y(x);
+    d.done = Math.abs(P) <= l, d.value = d.done ? p : R;
+  };
+  let m, v;
+  const A = (x) => {
+    h(d.value) && (m = x, v = Pt({
+      keyframes: [d.value, g(d.value)],
+      velocity: cs(y, x, d.value),
+      // TODO: This should be passing * 1000
+      damping: i,
+      stiffness: r,
+      restDelta: l,
+      restSpeed: c
+    }));
+  };
+  return A(0), {
+    calculatedDuration: null,
+    next: (x) => {
+      let P = !1;
+      return !v && m === void 0 && (P = !0, S(x), A(x)), m !== void 0 && x >= m ? v.next(x - m) : (!P && S(x), d);
+    }
+  };
+}
+function qi(t, e, n) {
+  const s = [], i = n || j.mix || os, r = t.length - 1;
+  for (let o = 0; o < r; o++) {
+    let a = i(t[o], t[o + 1]);
+    if (e) {
+      const u = Array.isArray(e) ? e[o] || st : e;
+      a = Ot(u, a);
+    }
+    s.push(a);
+  }
+  return s;
+}
+function Zi(t, e, { clamp: n = !0, ease: s, mixer: i } = {}) {
+  const r = t.length;
+  if (W(r === e.length, "Both input and output ranges must be the same length"), r === 1)
+    return () => e[0];
+  if (r === 2 && e[0] === e[1])
+    return () => e[1];
+  const o = t[0] === t[1];
+  t[0] > t[r - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const a = qi(e, s, i), u = a.length, l = (c) => {
+    if (o && c < t[0])
+      return e[0];
+    let f = 0;
+    if (u > 1)
+      for (; f < t.length - 2 && !(c < t[f + 1]); f++)
+        ;
+    const d = /* @__PURE__ */ jn(t[f], t[f + 1], c);
+    return a[f](d);
+  };
+  return n ? (c) => l(X(t[0], t[r - 1], c)) : l;
+}
+function Ji(t, e) {
+  const n = t[t.length - 1];
+  for (let s = 1; s <= e; s++) {
+    const i = /* @__PURE__ */ jn(0, e, s);
+    t.push(yt(n, 1, i));
+  }
+}
+function Qi(t) {
+  const e = [0];
+  return Ji(e, t.length - 1), e;
+}
+function tr(t, e) {
+  return t.map((n) => n * e);
+}
+function er(t, e) {
+  return t.map(() => e || qn).splice(0, t.length - 1);
+}
+function J({ duration: t = 300, keyframes: e, times: n, ease: s = "easeInOut" }) {
+  const i = hi(s) ? s.map(Ye) : Ye(s), r = {
+    done: !1,
+    value: e[0]
+  }, o = tr(
+    // 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 : Qi(e),
+    t
+  ), a = Zi(o, e, {
+    ease: Array.isArray(i) ? i : er(e, i)
+  });
+  return {
+    calculatedDuration: t,
+    next: (u) => (r.value = a(u), r.done = u >= t, r)
+  };
+}
+const nr = (t) => t !== null;
+function Ce(t, { repeat: e, repeatType: n = "loop" }, s, i = 1) {
+  const r = t.filter(nr), a = i < 0 || e && n !== "loop" && e % 2 === 1 ? 0 : r.length - 1;
+  return !a || s === void 0 ? r[a] : s;
+}
+const sr = {
+  decay: Zt,
+  inertia: Zt,
+  tween: J,
+  keyframes: J,
+  spring: Pt
+};
+function us(t) {
+  typeof t.type == "string" && (t.type = sr[t.type]);
+}
+class Pe {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((e) => {
+      this.resolve = e;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  /**
+   * Allows the animation to be awaited.
+   *
+   * @deprecated Use `finished` instead.
+   */
+  then(e, n) {
+    return this.finished.then(e, n);
+  }
+}
+const ir = (t) => t / 100;
+class De extends Pe {
+  constructor(e) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+      var s, i;
+      const { motionValue: n } = this.options;
+      n && n.updatedAt !== I.now() && this.tick(I.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), (i = (s = this.options).onStop) == null || i.call(s));
+    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: e } = this;
+    us(e);
+    const { type: n = J, repeat: s = 0, repeatDelay: i = 0, repeatType: r, velocity: o = 0 } = e;
+    let { keyframes: a } = e;
+    const u = n || J;
+    process.env.NODE_ENV !== "production" && u !== J && W(a.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${a}`), u !== J && typeof a[0] != "number" && (this.mixKeyframes = Ot(ir, os(a[0], a[1])), a = [0, 100]);
+    const l = u({ ...e, keyframes: a });
+    r === "mirror" && (this.mirroredGenerator = u({
+      ...e,
+      keyframes: [...a].reverse(),
+      velocity: -o
+    })), l.calculatedDuration === null && (l.calculatedDuration = Me(l));
+    const { calculatedDuration: c } = l;
+    this.calculatedDuration = c, this.resolvedDuration = c + i, this.totalDuration = this.resolvedDuration * (s + 1) - i, this.generator = l;
+  }
+  updateTime(e) {
+    const n = Math.round(e - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = n;
+  }
+  tick(e, n = !1) {
+    const { generator: s, totalDuration: i, mixKeyframes: r, mirroredGenerator: o, resolvedDuration: a, calculatedDuration: u } = this;
+    if (this.startTime === null)
+      return s.next(0);
+    const { delay: l = 0, keyframes: c, repeat: f, repeatType: d, repeatDelay: h, type: g, onUpdate: T, finalKeyframe: w } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - i / this.speed, this.startTime)), n ? this.currentTime = e : this.updateTime(e);
+    const p = this.currentTime - l * (this.playbackSpeed >= 0 ? 1 : -1), V = this.playbackSpeed >= 0 ? p < 0 : p > i;
+    this.currentTime = Math.max(p, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = i);
+    let y = this.currentTime, S = s;
+    if (f) {
+      const x = Math.min(this.currentTime, i) / a;
+      let P = Math.floor(x), R = x % 1;
+      !R && x >= 1 && (R = 1), R === 1 && P--, P = Math.min(P, f + 1), !!(P % 2) && (d === "reverse" ? (R = 1 - R, h && (R -= h / a)) : d === "mirror" && (S = o)), y = X(0, 1, R) * a;
+    }
+    const m = V ? { done: !1, value: c[0] } : S.next(y);
+    r && (m.value = r(m.value));
+    let { done: v } = m;
+    !V && u !== null && (v = this.playbackSpeed >= 0 ? this.currentTime >= i : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && v);
+    return A && g !== Zt && (m.value = Ce(c, this.options, w, this.speed)), T && T(m.value), A && 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(e, n) {
+    return this.finished.then(e, n);
+  }
+  get duration() {
+    return /* @__PURE__ */ K(this.calculatedDuration);
+  }
+  get time() {
+    return /* @__PURE__ */ K(this.currentTime);
+  }
+  set time(e) {
+    var n;
+    e = /* @__PURE__ */ N(e), this.currentTime = e, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.playbackSpeed), (n = this.driver) == null || n.start(!1);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(e) {
+    this.updateTime(I.now());
+    const n = this.playbackSpeed !== e;
+    this.playbackSpeed = e, n && (this.time = /* @__PURE__ */ K(this.currentTime));
+  }
+  play() {
+    var i, r;
+    if (this.isStopped)
+      return;
+    const { driver: e = $i, startTime: n } = this.options;
+    this.driver || (this.driver = e((o) => this.tick(o))), (r = (i = this.options).onPlay) == null || r.call(i);
+    const s = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = n ?? s), 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(I.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    var e, n;
+    this.notifyFinished(), this.teardown(), this.state = "finished", (n = (e = this.options).onComplete) == null || n.call(e);
+  }
+  cancel() {
+    var e, n;
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), (n = (e = this.options).onCancel) == null || n.call(e);
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(e) {
+    return this.startTime = 0, this.tick(e, !0);
+  }
+  attachTimeline(e) {
+    var n;
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), (n = this.driver) == null || n.stop(), e.observe(this);
+  }
+}
+function rr(t) {
+  for (let e = 1; e < t.length; e++)
+    t[e] ?? (t[e] = t[e - 1]);
+}
+const U = (t) => t * 180 / Math.PI, Jt = (t) => {
+  const e = U(Math.atan2(t[1], t[0]));
+  return Qt(e);
+}, or = {
+  x: 4,
+  y: 5,
+  translateX: 4,
+  translateY: 5,
+  scaleX: 0,
+  scaleY: 3,
+  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
+  rotate: Jt,
+  rotateZ: Jt,
+  skewX: (t) => U(Math.atan(t[1])),
+  skewY: (t) => U(Math.atan(t[2])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
+}, Qt = (t) => (t = t % 360, t < 0 && (t += 360), t), tn = Jt, en = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), nn = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), ar = {
+  x: 12,
+  y: 13,
+  z: 14,
+  translateX: 12,
+  translateY: 13,
+  translateZ: 14,
+  scaleX: en,
+  scaleY: nn,
+  scale: (t) => (en(t) + nn(t)) / 2,
+  rotateX: (t) => Qt(U(Math.atan2(t[6], t[5]))),
+  rotateY: (t) => Qt(U(Math.atan2(-t[2], t[0]))),
+  rotateZ: tn,
+  rotate: tn,
+  skewX: (t) => U(Math.atan(t[4])),
+  skewY: (t) => U(Math.atan(t[1])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
+};
+function te(t) {
+  return t.includes("scale") ? 1 : 0;
+}
+function ee(t, e) {
+  if (!t || t === "none")
+    return te(e);
+  const n = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
+  let s, i;
+  if (n)
+    s = ar, i = n;
+  else {
+    const a = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+    s = or, i = a;
+  }
+  if (!i)
+    return te(e);
+  const r = s[e], o = i[1].split(",").map(ur);
+  return typeof r == "function" ? r(o) : o[r];
+}
+const cr = (t, e) => {
+  const { transform: n = "none" } = getComputedStyle(t);
+  return ee(n, e);
+};
+function ur(t) {
+  return parseFloat(t.trim());
+}
+const ot = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], at = new Set(ot), sn = (t) => t === it || t === b, lr = /* @__PURE__ */ new Set(["x", "y", "z"]), fr = ot.filter((t) => !lr.has(t));
+function dr(t) {
+  const e = [];
+  return fr.forEach((n) => {
+    const s = t.getValue(n);
+    s !== void 0 && (e.push([n, s.get()]), s.set(n.startsWith("scale") ? 1 : 0));
+  }), e;
+}
+const G = {
+  // 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: (t, { transform: e }) => ee(e, "x"),
+  y: (t, { transform: e }) => ee(e, "y")
+};
+G.translateX = G.x;
+G.translateY = G.y;
+const H = /* @__PURE__ */ new Set();
+let ne = !1, se = !1, ie = !1;
+function ls() {
+  if (se) {
+    const t = Array.from(H).filter((s) => s.needsMeasurement), e = new Set(t.map((s) => s.element)), n = /* @__PURE__ */ new Map();
+    e.forEach((s) => {
+      const i = dr(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 a;
+        (a = s.getValue(r)) == null || a.set(o);
+      });
+    }), t.forEach((s) => s.measureEndState()), t.forEach((s) => {
+      s.suspendedScrollY !== void 0 && window.scrollTo(0, s.suspendedScrollY);
+    });
+  }
+  se = !1, ne = !1, H.forEach((t) => t.complete(ie)), H.clear();
+}
+function fs() {
+  H.forEach((t) => {
+    t.readKeyframes(), t.needsMeasurement && (se = !0);
+  });
+}
+function hr() {
+  ie = !0, fs(), ls(), ie = !1;
+}
+class Fe {
+  constructor(e, n, s, i, r, o = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...e], this.onComplete = n, this.name = s, this.motionValue = i, this.element = r, this.isAsync = o;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (H.add(this), ne || (ne = !0, k.read(fs), k.resolveKeyframes(ls))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, name: n, element: s, motionValue: i } = this;
+    if (e[0] === null) {
+      const r = i == null ? void 0 : i.get(), o = e[e.length - 1];
+      if (r !== void 0)
+        e[0] = r;
+      else if (s && n) {
+        const a = s.readValue(n, o);
+        a != null && (e[0] = a);
+      }
+      e[0] === void 0 && (e[0] = o), i && r === void 0 && i.set(e[0]);
+    }
+    rr(e);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(e = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, e), H.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (H.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}
+const pr = (t) => t.startsWith("--");
+function mr(t, e, n) {
+  pr(e) ? t.style.setProperty(e, n) : t.style[e] = n;
+}
+const gr = /* @__PURE__ */ ye(() => window.ScrollTimeline !== void 0), yr = {};
+function br(t, e) {
+  const n = /* @__PURE__ */ ye(t);
+  return () => yr[e] ?? n();
+}
+const ds = /* @__PURE__ */ br(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing"), ut = ([t, e, n, s]) => `cubic-bezier(${t}, ${e}, ${n}, ${s})`, rn = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ ut([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ ut([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ ut([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ ut([0.33, 1.53, 0.69, 0.99])
+};
+function hs(t, e) {
+  if (t)
+    return typeof t == "function" ? ds() ? as(t, e) : "ease-out" : Zn(t) ? ut(t) : Array.isArray(t) ? t.map((n) => hs(n, e) || rn.easeOut) : rn[t];
+}
+function Tr(t, e, n, { delay: s = 0, duration: i = 300, repeat: r = 0, repeatType: o = "loop", ease: a = "easeOut", times: u } = {}, l = void 0) {
+  const c = {
+    [e]: n
+  };
+  u && (c.offset = u);
+  const f = hs(a, i);
+  Array.isArray(f) && (c.easing = f);
+  const d = {
+    delay: s,
+    duration: i,
+    easing: Array.isArray(f) ? "linear" : f,
+    fill: "both",
+    iterations: r + 1,
+    direction: o === "reverse" ? "alternate" : "normal"
+  };
+  return l && (d.pseudoElement = l), t.animate(c, d);
+}
+function ps(t) {
+  return typeof t == "function" && "applyToOptions" in t;
+}
+function vr({ type: t, ...e }) {
+  return ps(t) && ds() ? t.applyToOptions(e) : (e.duration ?? (e.duration = 300), e.ease ?? (e.ease = "easeOut"), e);
+}
+class wr extends Pe {
+  constructor(e) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, !e)
+      return;
+    const { element: n, name: s, keyframes: i, pseudoElement: r, allowFlatten: o = !1, finalKeyframe: a, onComplete: u } = e;
+    this.isPseudoElement = !!r, this.allowFlatten = o, this.options = e, W(typeof e.type != "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "motion"?`);
+    const l = vr(e);
+    this.animation = Tr(n, s, i, l, r), l.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !r) {
+        const c = Ce(i, this.options, a, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(c) : mr(n, s, c), this.animation.cancel();
+      }
+      u == null || u(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    var e, n;
+    (n = (e = this.animation).finish) == null || n.call(e);
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: e } = this;
+    e === "idle" || e === "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() {
+    var e, n;
+    this.isPseudoElement || (n = (e = this.animation).commitStyles) == null || n.call(e);
+  }
+  get duration() {
+    var n, s;
+    const e = ((s = (n = this.animation.effect) == null ? void 0 : n.getComputedTiming) == null ? void 0 : s.call(n).duration) || 0;
+    return /* @__PURE__ */ K(Number(e));
+  }
+  get time() {
+    return /* @__PURE__ */ K(Number(this.animation.currentTime) || 0);
+  }
+  set time(e) {
+    this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ N(e);
+  }
+  /**
+   * The playback speed of the animation.
+   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+   */
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(e) {
+    e < 0 && (this.finishedTime = null), this.animation.playbackRate = e;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return Number(this.animation.startTime);
+  }
+  set startTime(e) {
+    this.animation.startTime = e;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: e, observe: n }) {
+    var s;
+    return this.allowFlatten && ((s = this.animation.effect) == null || s.updateTiming({ easing: "linear" })), this.animation.onfinish = null, e && gr() ? (this.animation.timeline = e, st) : n(this);
+  }
+}
+const ms = {
+  anticipate: Yn,
+  backInOut: Hn,
+  circInOut: Xn
+};
+function xr(t) {
+  return t in ms;
+}
+function Vr(t) {
+  typeof t.ease == "string" && xr(t.ease) && (t.ease = ms[t.ease]);
+}
+const on = 10;
+class Sr extends wr {
+  constructor(e) {
+    Vr(e), us(e), super(e), e.startTime && (this.startTime = e.startTime), this.options = e;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read commited 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(e) {
+    const { motionValue: n, onUpdate: s, onComplete: i, element: r, ...o } = this.options;
+    if (!n)
+      return;
+    if (e !== void 0) {
+      n.set(e);
+      return;
+    }
+    const a = new De({
+      ...o,
+      autoplay: !1
+    }), u = /* @__PURE__ */ N(this.finishedTime ?? this.time);
+    n.setWithVelocity(a.sample(u - on).value, a.sample(u).value, on), a.stop();
+  }
+}
+const an = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(rt.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url("));
+function Ar(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 Mr(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 = an(i, e), a = an(r, e);
+  return nt(o === a, `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 || !a ? !1 : Ar(t) || (n === "spring" || ps(n)) && s;
+}
+function Re(t) {
+  return ri(t) && "offsetHeight" in t;
+}
+const Cr = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Could be re-enabled now we have support for linear() easing
+  // "background-color"
+]), Pr = /* @__PURE__ */ ye(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function Dr(t) {
+  var l;
+  const { motionValue: e, name: n, repeatDelay: s, repeatType: i, damping: r, type: o } = t;
+  if (!Re((l = e == null ? void 0 : e.owner) == null ? void 0 : l.current))
+    return !1;
+  const { onUpdate: a, transformTemplate: u } = e.owner.getProps();
+  return Pr() && n && Cr.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.
+   */
+  !a && !s && i !== "mirror" && r !== 0 && o !== "inertia";
+}
+const Fr = 40;
+class Rr extends Pe {
+  constructor({ autoplay: e = !0, delay: n = 0, type: s = "keyframes", repeat: i = 0, repeatDelay: r = 0, repeatType: o = "loop", keyframes: a, name: u, motionValue: l, element: c, ...f }) {
+    var g;
+    super(), this.stop = () => {
+      var T, w;
+      this._animation && (this._animation.stop(), (T = this.stopTimeline) == null || T.call(this)), (w = this.keyframeResolver) == null || w.cancel();
+    }, this.createdAt = I.now();
+    const d = {
+      autoplay: e,
+      delay: n,
+      type: s,
+      repeat: i,
+      repeatDelay: r,
+      repeatType: o,
+      name: u,
+      motionValue: l,
+      element: c,
+      ...f
+    }, h = (c == null ? void 0 : c.KeyframeResolver) || Fe;
+    this.keyframeResolver = new h(a, (T, w, p) => this.onKeyframesResolved(T, w, d, !p), u, l, c), (g = this.keyframeResolver) == null || g.scheduleResolve();
+  }
+  onKeyframesResolved(e, n, s, i) {
+    this.keyframeResolver = void 0;
+    const { name: r, type: o, velocity: a, delay: u, isHandoff: l, onUpdate: c } = s;
+    this.resolvedAt = I.now(), Mr(e, r, o, a) || ((j.instantAnimations || !u) && (c == null || c(Ce(e, s, n))), e[0] = e[e.length - 1], s.duration = 0, s.repeat = 0);
+    const d = {
+      startTime: i ? this.resolvedAt ? this.resolvedAt - this.createdAt > Fr ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: n,
+      ...s,
+      keyframes: e
+    }, h = !l && Dr(d) ? new Sr({
+      ...d,
+      element: d.motionValue.owner.current
+    }) : new De(d);
+    h.finished.then(() => this.notifyFinished()).catch(st), this.pendingTimeline && (this.stopTimeline = h.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = h;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(e, n) {
+    return this.finished.finally(e).then(() => {
+    });
+  }
+  get animation() {
+    var e;
+    return this._animation || ((e = this.keyframeResolver) == null || e.resume(), hr()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(e) {
+    this.animation.time = e;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(e) {
+    this.animation.speed = e;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(e) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(e) : this.pendingTimeline = e, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    var e;
+    this._animation && this.animation.cancel(), (e = this.keyframeResolver) == null || e.cancel();
+  }
+}
+const Er = (
+  // 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 Or(t) {
+  const e = Er.exec(t);
+  if (!e)
+    return [,];
+  const [, n, s, i] = e;
+  return [`--${n ?? s}`, i];
+}
+const Ir = 4;
+function gs(t, e, n = 1) {
+  W(n <= Ir, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`);
+  const [s, i] = Or(t);
+  if (!s)
+    return;
+  const r = window.getComputedStyle(e).getPropertyValue(s);
+  if (r) {
+    const o = r.trim();
+    return Bn(o) ? parseFloat(o) : o;
+  }
+  return xe(i) ? gs(i, e, n + 1) : i;
+}
+function ys(t, e) {
+  return (t == null ? void 0 : t[e]) ?? (t == null ? void 0 : t.default) ?? t;
+}
+const bs = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...ot
+]), kr = {
+  test: (t) => t === "auto",
+  parse: (t) => t
+}, Ts = (t) => (e) => e.test(t), vs = [it, b, Q, $, Ai, Si, kr], cn = (t) => vs.find(Ts(t));
+function Nr(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || Kn(t) : !0;
+}
+const Lr = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function Br(t) {
+  const [e, n] = t.slice(0, -1).split("(");
+  if (e === "drop-shadow")
+    return t;
+  const [s] = n.match(Ve) || [];
+  if (!s)
+    return t;
+  const i = n.replace(s, "");
+  let r = Lr.has(e) ? 1 : 0;
+  return s !== n && (r *= 100), e + "(" + r + i + ")";
+}
+const Kr = /\b([a-z-]*)\(.*?\)/gu, re = {
+  ...rt,
+  getAnimatableNone: (t) => {
+    const e = t.match(Kr);
+    return e ? e.map(Br).join(" ") : t;
+  }
+}, un = {
+  ...it,
+  transform: Math.round
+}, jr = {
+  rotate: $,
+  rotateX: $,
+  rotateY: $,
+  rotateZ: $,
+  scale: Tt,
+  scaleX: Tt,
+  scaleY: Tt,
+  scaleZ: Tt,
+  skew: $,
+  skewX: $,
+  skewY: $,
+  distance: b,
+  translateX: b,
+  translateY: b,
+  translateZ: b,
+  x: b,
+  y: b,
+  z: b,
+  perspective: b,
+  transformPerspective: b,
+  opacity: ft,
+  originX: Xe,
+  originY: Xe,
+  originZ: b
+}, Ee = {
+  // Border props
+  borderWidth: b,
+  borderTopWidth: b,
+  borderRightWidth: b,
+  borderBottomWidth: b,
+  borderLeftWidth: b,
+  borderRadius: b,
+  radius: b,
+  borderTopLeftRadius: b,
+  borderTopRightRadius: b,
+  borderBottomRightRadius: b,
+  borderBottomLeftRadius: b,
+  // Positioning props
+  width: b,
+  maxWidth: b,
+  height: b,
+  maxHeight: b,
+  top: b,
+  right: b,
+  bottom: b,
+  left: b,
+  // Spacing props
+  padding: b,
+  paddingTop: b,
+  paddingRight: b,
+  paddingBottom: b,
+  paddingLeft: b,
+  margin: b,
+  marginTop: b,
+  marginRight: b,
+  marginBottom: b,
+  marginLeft: b,
+  // Misc
+  backgroundPositionX: b,
+  backgroundPositionY: b,
+  ...jr,
+  zIndex: un,
+  // SVG
+  fillOpacity: ft,
+  strokeOpacity: ft,
+  numOctaves: un
+}, $r = {
+  ...Ee,
+  // Color props
+  color: C,
+  backgroundColor: C,
+  outlineColor: C,
+  fill: C,
+  stroke: C,
+  // Border props
+  borderColor: C,
+  borderTopColor: C,
+  borderRightColor: C,
+  borderBottomColor: C,
+  borderLeftColor: C,
+  filter: re,
+  WebkitFilter: re
+}, ws = (t) => $r[t];
+function xs(t, e) {
+  let n = ws(t);
+  return n !== re && (n = rt), n.getAnimatableNone ? n.getAnimatableNone(e) : void 0;
+}
+const Wr = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function _r(t, e, n) {
+  let s = 0, i;
+  for (; s < t.length && !i; ) {
+    const r = t[s];
+    typeof r == "string" && !Wr.has(r) && dt(r).values.length && (i = t[s]), s++;
+  }
+  if (i && n)
+    for (const r of e)
+      t[r] = xs(n, i);
+}
+class zr extends Fe {
+  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 u = 0; u < e.length; u++) {
+      let l = e[u];
+      if (typeof l == "string" && (l = l.trim(), xe(l))) {
+        const c = gs(l, n.current);
+        c !== void 0 && (e[u] = c), u === e.length - 1 && (this.finalKeyframe = l);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !bs.has(s) || e.length !== 2)
+      return;
+    const [i, r] = e, o = cn(i), a = cn(r);
+    if (o !== a)
+      if (sn(o) && sn(a))
+        for (let u = 0; u < e.length; u++) {
+          const l = e[u];
+          typeof l == "string" && (e[u] = parseFloat(l));
+        }
+      else G[s] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, s = [];
+    for (let i = 0; i < e.length; i++)
+      (e[i] === null || Nr(e[i])) && s.push(i);
+    s.length && _r(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 = G[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 a;
+    const { element: e, name: n, unresolvedKeyframes: s } = this;
+    if (!e || !e.current)
+      return;
+    const i = e.getValue(n);
+    i && i.jump(this.measuredOrigin, !1);
+    const r = s.length - 1, o = s[r];
+    s[r] = G[n](e.measureViewportBox(), window.getComputedStyle(e.current)), o !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = o), (a = this.removedTransforms) != null && a.length && this.removedTransforms.forEach(([u, l]) => {
+      e.getValue(u).set(l);
+    }), this.resolveNoneKeyframes();
+  }
+}
+function Ur(t, e, n) {
+  if (t instanceof EventTarget)
+    return [t];
+  if (typeof t == "string") {
+    let s = document;
+    const i = (n == null ? void 0 : n[t]) ?? s.querySelectorAll(t);
+    return i ? Array.from(i) : [];
+  }
+  return Array.from(t);
+}
+const Vs = (t, e) => e && typeof t == "number" ? e.transform(t) : t, ln = 30, Gr = (t) => !isNaN(parseFloat(t));
+class Hr {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(e, n = {}) {
+    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s, i = !0) => {
+      var o, a;
+      const r = I.now();
+      if (this.updatedAt !== r && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && ((o = this.events.change) == null || o.notify(this.current), this.dependents))
+        for (const u of this.dependents)
+          u.dirty();
+      i && ((a = this.events.renderRequest) == null || a.notify(this.current));
+    }, this.hasAnimated = !1, this.setCurrent(e), this.owner = n.owner;
+  }
+  setCurrent(e) {
+    this.current = e, this.updatedAt = I.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = Gr(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 process.env.NODE_ENV !== "production" && be(!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 $n());
+    const s = this.events[e].add(n);
+    return e === "change" ? () => {
+      s(), k.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`.
+   */
+  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();
+  }
+  dirty() {
+    var e;
+    (e = this.events.change) == null || e.notify(this.current);
+  }
+  addDependent(e) {
+    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(e);
+  }
+  removeDependent(e) {
+    this.dependents && this.dependents.delete(e);
+  }
+  /**
+   * 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 = I.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > ln)
+      return 0;
+    const n = Math.min(this.updatedAt - this.prevUpdatedAt, ln);
+    return Wn(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
+   */
+  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() {
+    var e, n;
+    (e = this.dependents) == null || e.clear(), (n = this.events.destroy) == null || n.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function Dt(t, e) {
+  return new Hr(t, e);
+}
+const { schedule: Yr } = /* @__PURE__ */ Jn(queueMicrotask, !1), fn = {
+  x: !1,
+  y: !1
+};
+function Ss() {
+  return fn.x || fn.y;
+}
+function As(t, e) {
+  const n = Ur(t), s = new AbortController(), i = {
+    passive: !0,
+    ...e,
+    signal: s.signal
+  };
+  return [n, i, () => s.abort()];
+}
+function dn(t) {
+  return !(t.pointerType === "touch" || Ss());
+}
+function Xr(t, e, n = {}) {
+  const [s, i, r] = As(t, n), o = (a) => {
+    if (!dn(a))
+      return;
+    const { target: u } = a, l = e(u, a);
+    if (typeof l != "function" || !u)
+      return;
+    const c = (f) => {
+      dn(f) && (l(f), u.removeEventListener("pointerleave", c));
+    };
+    u.addEventListener("pointerleave", c, i);
+  };
+  return s.forEach((a) => {
+    a.addEventListener("pointerenter", o, i);
+  }), r;
+}
+const Ms = (t, e) => e ? t === e ? !0 : Ms(t, e.parentElement) : !1, Cs = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, qr = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function Zr(t) {
+  return qr.has(t.tagName) || t.tabIndex !== -1;
+}
+const xt = /* @__PURE__ */ new WeakSet();
+function hn(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function _t(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
+}
+const Jr = (t, e) => {
+  const n = t.currentTarget;
+  if (!n)
+    return;
+  const s = hn(() => {
+    if (xt.has(n))
+      return;
+    _t(n, "down");
+    const i = hn(() => {
+      _t(n, "up");
+    }), r = () => _t(n, "cancel");
+    n.addEventListener("keyup", i, e), n.addEventListener("blur", r, e);
+  });
+  n.addEventListener("keydown", s, e), n.addEventListener("blur", () => n.removeEventListener("keydown", s), e);
+};
+function pn(t) {
+  return Cs(t) && !Ss();
+}
+function Qr(t, e, n = {}) {
+  const [s, i, r] = As(t, n), o = (a) => {
+    const u = a.currentTarget;
+    if (!pn(a))
+      return;
+    xt.add(u);
+    const l = e(u, a), c = (h, g) => {
+      window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", d), xt.has(u) && xt.delete(u), pn(h) && typeof l == "function" && l(h, { success: g });
+    }, f = (h) => {
+      c(h, u === window || u === document || n.useGlobalTarget || Ms(u, h.target));
+    }, d = (h) => {
+      c(h, !1);
+    };
+    window.addEventListener("pointerup", f, i), window.addEventListener("pointercancel", d, i);
+  };
+  return s.forEach((a) => {
+    (n.useGlobalTarget ? window : a).addEventListener("pointerdown", o, i), Re(a) && (a.addEventListener("focus", (l) => Jr(l, i)), !Zr(a) && !a.hasAttribute("tabindex") && (a.tabIndex = 0));
+  }), r;
+}
+const F = (t) => !!(t && t.getVelocity), to = [...vs, C, rt], eo = (t) => to.find(Ts(t)), Oe = et({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+});
+class no extends he.Component {
+  getSnapshotBeforeUpdate(e) {
+    const n = this.props.childRef.current;
+    if (n && e.isPresent && !this.props.isPresent) {
+      const s = n.offsetParent, i = Re(s) && s.offsetWidth || 0, r = this.props.sizeRef.current;
+      r.height = n.offsetHeight || 0, r.width = n.offsetWidth || 0, r.top = n.offsetTop, r.left = n.offsetLeft, r.right = i - r.width - r.left;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function so({ children: t, isPresent: e, anchorX: n }) {
+  const s = pe(), i = B(null), r = B({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0
+  }), { nonce: o } = E(Oe);
+  return In(() => {
+    const { width: a, height: u, top: l, left: c, right: f } = r.current;
+    if (e || !i.current || !a || !u)
+      return;
+    const d = n === "left" ? `left: ${c}` : `right: ${f}`;
+    i.current.dataset.motionPopId = s;
+    const h = document.createElement("style");
+    return o && (h.nonce = o), document.head.appendChild(h), h.sheet && h.sheet.insertRule(`
+          [data-motion-pop-id="${s}"] {
+            position: absolute !important;
+            width: ${a}px !important;
+            height: ${u}px !important;
+            ${d}px !important;
+            top: ${l}px !important;
+          }
+        `), () => {
+      document.head.contains(h) && document.head.removeChild(h);
+    };
+  }, [e]), O.jsx(no, { isPresent: e, childRef: i, sizeRef: r, children: he.cloneElement(t, { ref: i }) });
+}
+const io = ({ children: t, initial: e, isPresent: n, onExitComplete: s, custom: i, presenceAffectsLayout: r, mode: o, anchorX: a }) => {
+  const u = me(ro), l = pe();
+  let c = !0, f = Y(() => (c = !1, {
+    id: l,
+    initial: e,
+    isPresent: n,
+    custom: i,
+    onExitComplete: (d) => {
+      u.set(d, !0);
+      for (const h of u.values())
+        if (!h)
+          return;
+      s && s();
+    },
+    register: (d) => (u.set(d, !1), () => u.delete(d))
+  }), [n, u, s]);
+  return r && c && (f = { ...f }), Y(() => {
+    u.forEach((d, h) => u.set(h, !1));
+  }, [n]), he.useEffect(() => {
+    !n && !u.size && s && s();
+  }, [n]), o === "popLayout" && (t = O.jsx(so, { isPresent: n, anchorX: a, children: t })), O.jsx(Et.Provider, { value: f, children: t });
+};
+function ro() {
+  return /* @__PURE__ */ new Map();
+}
+function oo(t = !0) {
+  const e = E(Et);
+  if (e === null)
+    return [!0, null];
+  const { isPresent: n, onExitComplete: s, register: i } = e, r = pe();
+  Rt(() => {
+    if (t)
+      return i(r);
+  }, [t]);
+  const o = St(() => t && s && s(r), [r, s, t]);
+  return !n && s ? [!1, o] : [!0];
+}
+const vt = (t) => t.key || "";
+function mn(t) {
+  const e = [];
+  return Zs.forEach(t, (n) => {
+    Js(n) && e.push(n);
+  }), e;
+}
+const ao = ({ children: t, custom: e, initial: n = !0, onExitComplete: s, presenceAffectsLayout: i = !0, mode: r = "sync", propagate: o = !1, anchorX: a = "left" }) => {
+  const [u, l] = oo(o), c = Y(() => mn(t), [t]), f = o && !u ? [] : c.map(vt), d = B(!0), h = B(c), g = me(() => /* @__PURE__ */ new Map()), [T, w] = Vt(c), [p, V] = Vt(c);
+  Ln(() => {
+    d.current = !1, h.current = c;
+    for (let m = 0; m < p.length; m++) {
+      const v = vt(p[m]);
+      f.includes(v) ? g.delete(v) : g.get(v) !== !0 && g.set(v, !1);
+    }
+  }, [p, f.length, f.join("-")]);
+  const y = [];
+  if (c !== T) {
+    let m = [...c];
+    for (let v = 0; v < p.length; v++) {
+      const A = p[v], x = vt(A);
+      f.includes(x) || (m.splice(v, 0, A), y.push(A));
+    }
+    return r === "wait" && y.length && (m = y), V(mn(m)), w(c), null;
+  }
+  process.env.NODE_ENV !== "production" && r === "wait" && p.length > 1;
+  const { forceRender: S } = E(Nn);
+  return O.jsx(O.Fragment, { children: p.map((m) => {
+    const v = vt(m), A = o && !u ? !1 : c === p || f.includes(v), x = () => {
+      if (g.has(v))
+        g.set(v, !0);
+      else
+        return;
+      let P = !0;
+      g.forEach((R) => {
+        R || (P = !1);
+      }), P && (S == null || S(), V(h.current), o && (l == null || l()), s && s());
+    };
+    return O.jsx(io, { isPresent: A, initial: !d.current || n ? void 0 : !1, custom: e, presenceAffectsLayout: i, mode: r, onExitComplete: A ? void 0 : x, anchorX: a, children: m }, v);
+  }) });
+}, Ie = et({ strict: !1 }), gn = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, tt = {};
+for (const t in gn)
+  tt[t] = {
+    isEnabled: (e) => gn[t].some((n) => !!e[n])
+  };
+function oe(t) {
+  for (const e in t)
+    tt[e] = {
+      ...tt[e],
+      ...t[e]
+    };
+}
+function co({ children: t, features: e, strict: n = !1 }) {
+  const [, s] = Vt(!zt(e)), i = B(void 0);
+  if (!zt(e)) {
+    const { renderer: r, ...o } = e;
+    i.current = r, oe(o);
+  }
+  return Rt(() => {
+    zt(e) && e().then(({ renderer: r, ...o }) => {
+      oe(o), i.current = r, s(!0);
+    });
+  }, []), O.jsx(Ie.Provider, { value: { renderer: i.current, strict: n }, children: t });
+}
+function zt(t) {
+  return typeof t == "function";
+}
+const uo = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "ignoreStrict",
+  "viewport"
+]);
+function Ft(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || uo.has(t);
+}
+let Ps = (t) => !Ft(t);
+function lo(t) {
+  typeof t == "function" && (Ps = (e) => e.startsWith("on") ? !Ft(e) : t(e));
+}
+try {
+  lo(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function fo(t, e, n) {
+  const s = {};
+  for (const i in t)
+    i === "values" && typeof t.values == "object" || (Ps(i) || n === !0 && Ft(i) || !e && !Ft(i) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && i.startsWith("onDrag")) && (s[i] = t[i]);
+  return s;
+}
+function ho(t) {
+  if (typeof Proxy > "u")
+    return t;
+  const e = /* @__PURE__ */ new Map(), n = (...s) => (process.env.NODE_ENV !== "production" && be(!1, "motion() is deprecated. Use motion.create() instead."), t(...s));
+  return new Proxy(n, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: (s, i) => i === "create" ? t : (e.has(i) || e.set(i, t(i)), e.get(i))
+  });
+}
+const It = /* @__PURE__ */ et({});
+function kt(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+function ht(t) {
+  return typeof t == "string" || Array.isArray(t);
+}
+const ke = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], Ne = ["initial", ...ke];
+function Nt(t) {
+  return kt(t.animate) || Ne.some((e) => ht(t[e]));
+}
+function Ds(t) {
+  return !!(Nt(t) || t.variants);
+}
+function po(t, e) {
+  if (Nt(t)) {
+    const { initial: n, animate: s } = t;
+    return {
+      initial: n === !1 || ht(n) ? n : void 0,
+      animate: ht(s) ? s : void 0
+    };
+  }
+  return t.inherit !== !1 ? e : {};
+}
+function mo(t) {
+  const { initial: e, animate: n } = po(t, E(It));
+  return Y(() => ({ initial: e, animate: n }), [yn(e), yn(n)]);
+}
+function yn(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+const go = Symbol.for("motionComponentSymbol");
+function Fs(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+function yo(t, e, n) {
+  return St(
+    (s) => {
+      s && t.onMount && t.onMount(s), e && (s ? e.mount(s) : e.unmount()), n && (typeof n == "function" ? n(s) : Fs(n) && (n.current = s));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [e]
+  );
+}
+const Le = (t) => t.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase(), bo = "framerAppearId", Rs = "data-" + Le(bo), To = et({});
+function vo(t, e, n, s, i) {
+  var T, w;
+  const { visualElement: r } = E(It), o = E(Ie), a = E(Et), u = E(Oe).reducedMotion, l = B(null);
+  s = s || o.renderer, !l.current && s && (l.current = s(t, {
+    visualState: e,
+    parent: r,
+    props: n,
+    presenceContext: a,
+    blockInitialAnimation: a ? a.initial === !1 : !1,
+    reducedMotionConfig: u
+  }));
+  const c = l.current, f = E(To);
+  c && !c.projection && i && (c.type === "html" || c.type === "svg") && wo(l.current, n, i, f);
+  const d = B(!1);
+  In(() => {
+    c && d.current && c.update(n, a);
+  });
+  const h = n[Rs], g = B(!!h && !((T = window.MotionHandoffIsComplete) != null && T.call(window, h)) && ((w = window.MotionHasOptimisedAnimation) == null ? void 0 : w.call(window, h)));
+  return Ln(() => {
+    c && (d.current = !0, window.MotionIsMounted = !0, c.updateFeatures(), Yr.render(c.render), g.current && c.animationState && c.animationState.animateChanges());
+  }), Rt(() => {
+    c && (!g.current && c.animationState && c.animationState.animateChanges(), g.current && (queueMicrotask(() => {
+      var p;
+      (p = window.MotionHandoffMarkAsComplete) == null || p.call(window, h);
+    }), g.current = !1));
+  }), c;
+}
+function wo(t, e, n, s) {
+  const { layoutId: i, layout: r, drag: o, dragConstraints: a, layoutScroll: u, layoutRoot: l, layoutCrossfade: c } = e;
+  t.projection = new n(t.latestValues, e["data-framer-portal-id"] ? void 0 : Es(t.parent)), t.projection.setOptions({
+    layoutId: i,
+    layout: r,
+    alwaysMeasureLayout: !!o || a && Fs(a),
+    visualElement: t,
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof r == "string" ? r : "both",
+    initialPromotionConfig: s,
+    crossfade: c,
+    layoutScroll: u,
+    layoutRoot: l
+  });
+}
+function Es(t) {
+  if (t)
+    return t.options.allowProjection !== !1 ? t.projection : Es(t.parent);
+}
+function xo({ preloadedFeatures: t, createVisualElement: e, useRender: n, useVisualState: s, Component: i }) {
+  t && oe(t);
+  function r(a, u) {
+    let l;
+    const c = {
+      ...E(Oe),
+      ...a,
+      layoutId: Vo(a)
+    }, { isStatic: f } = c, d = mo(a), h = s(a, f);
+    if (!f && ge) {
+      So(c, t);
+      const g = Ao(c);
+      l = g.MeasureLayout, d.visualElement = vo(i, h, c, e, g.ProjectionNode);
+    }
+    return O.jsxs(It.Provider, { value: d, children: [l && d.visualElement ? O.jsx(l, { visualElement: d.visualElement, ...c }) : null, n(i, a, yo(h, d.visualElement, u), h, f, d.visualElement)] });
+  }
+  r.displayName = `motion.${typeof i == "string" ? i : `create(${i.displayName ?? i.name ?? ""})`}`;
+  const o = Qs(r);
+  return o[go] = i, o;
+}
+function Vo({ layoutId: t }) {
+  const e = E(Nn).id;
+  return e && t !== void 0 ? e + "-" + t : t;
+}
+function So(t, e) {
+  const n = E(Ie).strict;
+  if (process.env.NODE_ENV !== "production" && e && n) {
+    const s = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? nt(!1, s) : W(!1, s);
+  }
+}
+function Ao(t) {
+  const { drag: e, layout: n } = tt;
+  if (!e && !n)
+    return {};
+  const s = { ...e, ...n };
+  return {
+    MeasureLayout: e != null && e.isEnabled(t) || n != null && n.isEnabled(t) ? s.MeasureLayout : void 0,
+    ProjectionNode: s.ProjectionNode
+  };
+}
+const ae = {};
+function nc(t) {
+  for (const e in t)
+    ae[e] = t[e], we(e) && (ae[e].isCSSVariable = !0);
+}
+function Os(t, { layout: e, layoutId: n }) {
+  return at.has(t) || t.startsWith("origin") || (e || n !== void 0) && (!!ae[t] || t === "opacity");
+}
+const Mo = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, Co = ot.length;
+function Po(t, e, n) {
+  let s = "", i = !0;
+  for (let r = 0; r < Co; r++) {
+    const o = ot[r], a = t[o];
+    if (a === void 0)
+      continue;
+    let u = !0;
+    if (typeof a == "number" ? u = a === (o.startsWith("scale") ? 1 : 0) : u = parseFloat(a) === 0, !u || n) {
+      const l = Vs(a, Ee[o]);
+      if (!u) {
+        i = !1;
+        const c = Mo[o] || o;
+        s += `${c}(${l}) `;
+      }
+      n && (e[o] = l);
+    }
+  }
+  return s = s.trim(), n ? s = n(e, i ? "" : s) : i && (s = "none"), s;
+}
+function Be(t, e, n) {
+  const { style: s, vars: i, transformOrigin: r } = t;
+  let o = !1, a = !1;
+  for (const u in e) {
+    const l = e[u];
+    if (at.has(u)) {
+      o = !0;
+      continue;
+    } else if (we(u)) {
+      i[u] = l;
+      continue;
+    } else {
+      const c = Vs(l, Ee[u]);
+      u.startsWith("origin") ? (a = !0, r[u] = c) : s[u] = c;
+    }
+  }
+  if (e.transform || (o || n ? s.transform = Po(e, t.transform, n) : s.transform && (s.transform = "none")), a) {
+    const { originX: u = "50%", originY: l = "50%", originZ: c = 0 } = r;
+    s.transformOrigin = `${u} ${l} ${c}`;
+  }
+}
+const Ke = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+function Is(t, e, n) {
+  for (const s in e)
+    !F(e[s]) && !Os(s, n) && (t[s] = e[s]);
+}
+function Do({ transformTemplate: t }, e) {
+  return Y(() => {
+    const n = Ke();
+    return Be(n, e, t), Object.assign({}, n.vars, n.style);
+  }, [e]);
+}
+function Fo(t, e) {
+  const n = t.style || {}, s = {};
+  return Is(s, n, t), Object.assign(s, Do(t, e)), s;
+}
+function Ro(t, e) {
+  const n = {}, s = Fo(t, e);
+  return t.drag && t.dragListener !== !1 && (n.draggable = !1, s.userSelect = s.WebkitUserSelect = s.WebkitTouchCallout = "none", s.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (n.tabIndex = 0), n.style = s, n;
+}
+const Eo = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, Oo = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function Io(t, e, n = 1, s = 0, i = !0) {
+  t.pathLength = 1;
+  const r = i ? Eo : Oo;
+  t[r.offset] = b.transform(-s);
+  const o = b.transform(e), a = b.transform(n);
+  t[r.array] = `${o} ${a}`;
+}
+function ks(t, {
+  attrX: e,
+  attrY: n,
+  attrScale: s,
+  pathLength: i,
+  pathSpacing: r = 1,
+  pathOffset: o = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...a
+}, u, l, c) {
+  if (Be(t, a, l), u) {
+    t.style.viewBox && (t.attrs.viewBox = t.style.viewBox);
+    return;
+  }
+  t.attrs = t.style, t.style = {};
+  const { attrs: f, style: d } = t;
+  f.transform && (d.transform = f.transform, delete f.transform), (d.transform || f.transformOrigin) && (d.transformOrigin = f.transformOrigin ?? "50% 50%", delete f.transformOrigin), d.transform && (d.transformBox = (c == null ? void 0 : c.transformBox) ?? "fill-box", delete f.transformBox), e !== void 0 && (f.x = e), n !== void 0 && (f.y = n), s !== void 0 && (f.scale = s), i !== void 0 && Io(f, i, r, o, !1);
+}
+const Ns = () => ({
+  ...Ke(),
+  attrs: {}
+}), Ls = (t) => typeof t == "string" && t.toLowerCase() === "svg";
+function ko(t, e, n, s) {
+  const i = Y(() => {
+    const r = Ns();
+    return ks(r, e, Ls(s), t.transformTemplate, t.style), {
+      ...r.attrs,
+      style: { ...r.style }
+    };
+  }, [e]);
+  if (t.style) {
+    const r = {};
+    Is(r, t.style, t), i.style = { ...r, ...i.style };
+  }
+  return i;
+}
+const No = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+function je(t) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof t != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    t.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(No.indexOf(t) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(t))
+    )
+  );
+}
+function Lo(t = !1) {
+  return (n, s, i, { latestValues: r }, o) => {
+    const u = (je(n) ? ko : Ro)(s, r, o, n), l = fo(s, typeof n == "string", t), c = n !== kn ? { ...l, ...u, ref: i } : {}, { children: f } = s, d = Y(() => F(f) ? f.get() : f, [f]);
+    return ti(n, {
+      ...c,
+      children: d
+    });
+  };
+}
+function bn(t) {
+  const e = [{}, {}];
+  return t == null || t.values.forEach((n, s) => {
+    e[0][s] = n.get(), e[1][s] = n.getVelocity();
+  }), e;
+}
+function $e(t, e, n, s) {
+  if (typeof e == "function") {
+    const [i, r] = bn(s);
+    e = e(n !== void 0 ? n : t.custom, i, r);
+  }
+  if (typeof e == "string" && (e = t.variants && t.variants[e]), typeof e == "function") {
+    const [i, r] = bn(s);
+    e = e(n !== void 0 ? n : t.custom, i, r);
+  }
+  return e;
+}
+function Bo(t) {
+  return F(t) ? t.get() : t;
+}
+function Ko({ scrapeMotionValuesFromProps: t, createRenderState: e }, n, s, i) {
+  return {
+    latestValues: jo(n, s, i, t),
+    renderState: e()
+  };
+}
+const Bs = (t) => (e, n) => {
+  const s = E(It), i = E(Et), r = () => Ko(t, e, s, i);
+  return n ? r() : me(r);
+};
+function jo(t, e, n, s) {
+  const i = {}, r = s(t, {});
+  for (const d in r)
+    i[d] = Bo(r[d]);
+  let { initial: o, animate: a } = t;
+  const u = Nt(t), l = Ds(t);
+  e && l && !u && t.inherit !== !1 && (o === void 0 && (o = e.initial), a === void 0 && (a = e.animate));
+  let c = n ? n.initial === !1 : !1;
+  c = c || o === !1;
+  const f = c ? a : o;
+  if (f && typeof f != "boolean" && !kt(f)) {
+    const d = Array.isArray(f) ? f : [f];
+    for (let h = 0; h < d.length; h++) {
+      const g = $e(t, d[h]);
+      if (g) {
+        const { transitionEnd: T, transition: w, ...p } = g;
+        for (const V in p) {
+          let y = p[V];
+          if (Array.isArray(y)) {
+            const S = c ? y.length - 1 : 0;
+            y = y[S];
+          }
+          y !== null && (i[V] = y);
+        }
+        for (const V in T)
+          i[V] = T[V];
+      }
+    }
+  }
+  return i;
+}
+function We(t, e, n) {
+  var r;
+  const { style: s } = t, i = {};
+  for (const o in s)
+    (F(s[o]) || e.style && F(e.style[o]) || Os(o, t) || ((r = n == null ? void 0 : n.getValue(o)) == null ? void 0 : r.liveStyle) !== void 0) && (i[o] = s[o]);
+  return i;
+}
+const $o = {
+  useVisualState: Bs({
+    scrapeMotionValuesFromProps: We,
+    createRenderState: Ke
+  })
+};
+function Ks(t, e, n) {
+  const s = We(t, e, n);
+  for (const i in t)
+    if (F(t[i]) || F(e[i])) {
+      const r = ot.indexOf(i) !== -1 ? "attr" + i.charAt(0).toUpperCase() + i.substring(1) : i;
+      s[r] = t[i];
+    }
+  return s;
+}
+const Wo = {
+  useVisualState: Bs({
+    scrapeMotionValuesFromProps: Ks,
+    createRenderState: Ns
+  })
+};
+function _o(t, e) {
+  return function(s, { forwardMotionProps: i } = { forwardMotionProps: !1 }) {
+    const o = {
+      ...je(s) ? Wo : $o,
+      preloadedFeatures: t,
+      useRender: Lo(i),
+      createVisualElement: e,
+      Component: s
+    };
+    return xo(o);
+  };
+}
+const zo = /* @__PURE__ */ _o(), Uo = /* @__PURE__ */ ho(zo);
+function pt(t, e, n) {
+  const s = t.getProps();
+  return $e(s, e, n !== void 0 ? n : s.custom, t);
+}
+const ce = (t) => Array.isArray(t);
+function Go(t, e, n) {
+  t.hasValue(e) ? t.getValue(e).set(n) : t.addValue(e, Dt(n));
+}
+function Ho(t) {
+  return ce(t) ? t[t.length - 1] || 0 : t;
+}
+function Yo(t, e) {
+  const n = pt(t, e);
+  let { transitionEnd: s = {}, transition: i = {}, ...r } = n || {};
+  r = { ...r, ...s };
+  for (const o in r) {
+    const a = Ho(r[o]);
+    Go(t, o, a);
+  }
+}
+function Xo(t) {
+  return !!(F(t) && t.add);
+}
+function qo(t, e) {
+  const n = t.getValue("willChange");
+  if (Xo(n))
+    return n.add(e);
+  if (!n && j.WillChange) {
+    const s = new j.WillChange("auto");
+    t.addValue("willChange", s), s.add(e);
+  }
+}
+function Zo(t) {
+  return t.props[Rs];
+}
+const Jo = (t) => t !== null;
+function Qo(t, { repeat: e, repeatType: n = "loop" }, s) {
+  const i = t.filter(Jo), r = e && n !== "loop" && e % 2 === 1 ? 0 : i.length - 1;
+  return i[r];
+}
+const ta = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, ea = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), na = {
+  type: "keyframes",
+  duration: 0.8
+}, sa = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, ia = (t, { keyframes: e }) => e.length > 2 ? na : at.has(t) ? t.startsWith("scale") ? ea(e[1]) : ta : sa;
+function ra({ when: t, delay: e, delayChildren: n, staggerChildren: s, staggerDirection: i, repeat: r, repeatType: o, repeatDelay: a, from: u, elapsed: l, ...c }) {
+  return !!Object.keys(c).length;
+}
+const oa = (t, e, n, s = {}, i, r) => (o) => {
+  const a = ys(s, t) || {}, u = a.delay || s.delay || 0;
+  let { elapsed: l = 0 } = s;
+  l = l - /* @__PURE__ */ N(u);
+  const c = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...a,
+    delay: -l,
+    onUpdate: (d) => {
+      e.set(d), a.onUpdate && a.onUpdate(d);
+    },
+    onComplete: () => {
+      o(), a.onComplete && a.onComplete();
+    },
+    name: t,
+    motionValue: e,
+    element: r ? void 0 : i
+  };
+  ra(a) || Object.assign(c, ia(t, c)), c.duration && (c.duration = /* @__PURE__ */ N(c.duration)), c.repeatDelay && (c.repeatDelay = /* @__PURE__ */ N(c.repeatDelay)), c.from !== void 0 && (c.keyframes[0] = c.from);
+  let f = !1;
+  if ((c.type === !1 || c.duration === 0 && !c.repeatDelay) && (c.duration = 0, c.delay === 0 && (f = !0)), (j.instantAnimations || j.skipAnimations) && (f = !0, c.duration = 0, c.delay = 0), c.allowFlatten = !a.type && !a.ease, f && !r && e.get() !== void 0) {
+    const d = Qo(c.keyframes, a);
+    if (d !== void 0) {
+      k.update(() => {
+        c.onUpdate(d), c.onComplete();
+      });
+      return;
+    }
+  }
+  return a.isSync ? new De(c) : new Rr(c);
+};
+function aa({ protectedKeys: t, needsAnimating: e }, n) {
+  const s = t.hasOwnProperty(n) && e[n] !== !0;
+  return e[n] = !1, s;
+}
+function js(t, e, { delay: n = 0, transitionOverride: s, type: i } = {}) {
+  let { transition: r = t.getDefaultTransition(), transitionEnd: o, ...a } = e;
+  s && (r = s);
+  const u = [], l = i && t.animationState && t.animationState.getState()[i];
+  for (const c in a) {
+    const f = t.getValue(c, t.latestValues[c] ?? null), d = a[c];
+    if (d === void 0 || l && aa(l, c))
+      continue;
+    const h = {
+      delay: n,
+      ...ys(r || {}, c)
+    }, g = f.get();
+    if (g !== void 0 && !f.isAnimating && !Array.isArray(d) && d === g && !h.velocity)
+      continue;
+    let T = !1;
+    if (window.MotionHandoffAnimation) {
+      const p = Zo(t);
+      if (p) {
+        const V = window.MotionHandoffAnimation(p, c, k);
+        V !== null && (h.startTime = V, T = !0);
+      }
+    }
+    qo(t, c), f.start(oa(c, f, d, t.shouldReduceMotion && bs.has(c) ? { type: !1 } : h, t, T));
+    const w = f.animation;
+    w && u.push(w);
+  }
+  return o && Promise.all(u).then(() => {
+    k.update(() => {
+      o && Yo(t, o);
+    });
+  }), u;
+}
+function ue(t, e, n = {}) {
+  var u;
+  const s = pt(t, e, n.type === "exit" ? (u = t.presenceContext) == null ? void 0 : u.custom : void 0);
+  let { transition: i = t.getDefaultTransition() || {} } = s || {};
+  n.transitionOverride && (i = n.transitionOverride);
+  const r = s ? () => Promise.all(js(t, s, n)) : () => Promise.resolve(), o = t.variantChildren && t.variantChildren.size ? (l = 0) => {
+    const { delayChildren: c = 0, staggerChildren: f, staggerDirection: d } = i;
+    return ca(t, e, c + l, f, d, n);
+  } : () => Promise.resolve(), { when: a } = i;
+  if (a) {
+    const [l, c] = a === "beforeChildren" ? [r, o] : [o, r];
+    return l().then(() => c());
+  } else
+    return Promise.all([r(), o(n.delay)]);
+}
+function ca(t, e, n = 0, s = 0, i = 1, r) {
+  const o = [], a = (t.variantChildren.size - 1) * s, u = i === 1 ? (l = 0) => l * s : (l = 0) => a - l * s;
+  return Array.from(t.variantChildren).sort(ua).forEach((l, c) => {
+    l.notify("AnimationStart", e), o.push(ue(l, e, {
+      ...r,
+      delay: n + u(c)
+    }).then(() => l.notify("AnimationComplete", e)));
+  }), Promise.all(o);
+}
+function ua(t, e) {
+  return t.sortNodePosition(e);
+}
+function la(t, e, n = {}) {
+  t.notify("AnimationStart", e);
+  let s;
+  if (Array.isArray(e)) {
+    const i = e.map((r) => ue(t, r, n));
+    s = Promise.all(i);
+  } else if (typeof e == "string")
+    s = ue(t, e, n);
+  else {
+    const i = typeof e == "function" ? pt(t, e, n.custom) : e;
+    s = Promise.all(js(t, i, n));
+  }
+  return s.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+function $s(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;
+}
+const fa = Ne.length;
+function Ws(t) {
+  if (!t)
+    return;
+  if (!t.isControllingVariants) {
+    const n = t.parent ? Ws(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (n.initial = t.props.initial), n;
+  }
+  const e = {};
+  for (let n = 0; n < fa; n++) {
+    const s = Ne[n], i = t.props[s];
+    (ht(i) || i === !1) && (e[s] = i);
+  }
+  return e;
+}
+const da = [...ke].reverse(), ha = ke.length;
+function pa(t) {
+  return (e) => Promise.all(e.map(({ animation: n, options: s }) => la(t, n, s)));
+}
+function ma(t) {
+  let e = pa(t), n = Tn(), s = !0;
+  const i = (u) => (l, c) => {
+    var d;
+    const f = pt(t, c, u === "exit" ? (d = t.presenceContext) == null ? void 0 : d.custom : void 0);
+    if (f) {
+      const { transition: h, transitionEnd: g, ...T } = f;
+      l = { ...l, ...T, ...g };
+    }
+    return l;
+  };
+  function r(u) {
+    e = u(t);
+  }
+  function o(u) {
+    const { props: l } = t, c = Ws(t.parent) || {}, f = [], d = /* @__PURE__ */ new Set();
+    let h = {}, g = 1 / 0;
+    for (let w = 0; w < ha; w++) {
+      const p = da[w], V = n[p], y = l[p] !== void 0 ? l[p] : c[p], S = ht(y), m = p === u ? V.isActive : null;
+      m === !1 && (g = w);
+      let v = y === c[p] && y !== l[p] && S;
+      if (v && s && t.manuallyAnimateOnMount && (v = !1), V.protectedKeys = { ...h }, // 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
+      !y && !V.prevProp || // Or if the prop doesn't define an animation
+      kt(y) || typeof y == "boolean")
+        continue;
+      const A = ga(V.prevProp, y);
+      let x = A || // If we're making this variant active, we want to always make it active
+      p === u && V.isActive && !v && S || // If we removed a higher-priority variant (i is in reverse order)
+      w > g && S, P = !1;
+      const R = Array.isArray(y) ? y : [y];
+      let q = R.reduce(i(p), {});
+      m === !1 && (q = {});
+      const { prevResolvedValues: ze = {} } = V, Xs = {
+        ...ze,
+        ...q
+      }, Ue = (D) => {
+        x = !0, d.has(D) && (P = !0, d.delete(D)), V.needsAnimating[D] = !0;
+        const L = t.getValue(D);
+        L && (L.liveStyle = !1);
+      };
+      for (const D in Xs) {
+        const L = q[D], Lt = ze[D];
+        if (h.hasOwnProperty(D))
+          continue;
+        let Bt = !1;
+        ce(L) && ce(Lt) ? Bt = !$s(L, Lt) : Bt = L !== Lt, Bt ? L != null ? Ue(D) : d.add(D) : L !== void 0 && d.has(D) ? Ue(D) : V.protectedKeys[D] = !0;
+      }
+      V.prevProp = y, V.prevResolvedValues = q, V.isActive && (h = { ...h, ...q }), s && t.blockInitialAnimation && (x = !1), x && (!(v && A) || P) && f.push(...R.map((D) => ({
+        animation: D,
+        options: { type: p }
+      })));
+    }
+    if (d.size) {
+      const w = {};
+      if (typeof l.initial != "boolean") {
+        const p = pt(t, Array.isArray(l.initial) ? l.initial[0] : l.initial);
+        p && p.transition && (w.transition = p.transition);
+      }
+      d.forEach((p) => {
+        const V = t.getBaseTarget(p), y = t.getValue(p);
+        y && (y.liveStyle = !0), w[p] = V ?? null;
+      }), f.push({ animation: w });
+    }
+    let T = !!f.length;
+    return s && (l.initial === !1 || l.initial === l.animate) && !t.manuallyAnimateOnMount && (T = !1), s = !1, T ? e(f) : Promise.resolve();
+  }
+  function a(u, l) {
+    var f;
+    if (n[u].isActive === l)
+      return Promise.resolve();
+    (f = t.variantChildren) == null || f.forEach((d) => {
+      var h;
+      return (h = d.animationState) == null ? void 0 : h.setActive(u, l);
+    }), n[u].isActive = l;
+    const c = o(u);
+    for (const d in n)
+      n[d].protectedKeys = {};
+    return c;
+  }
+  return {
+    animateChanges: o,
+    setActive: a,
+    setAnimateFunction: r,
+    getState: () => n,
+    reset: () => {
+      n = Tn(), s = !0;
+    }
+  };
+}
+function ga(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !$s(e, t) : !1;
+}
+function _(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function Tn() {
+  return {
+    animate: _(!0),
+    whileInView: _(),
+    whileHover: _(),
+    whileTap: _(),
+    whileDrag: _(),
+    whileFocus: _(),
+    exit: _()
+  };
+}
+class ct {
+  constructor(e) {
+    this.isMounted = !1, this.node = e;
+  }
+  update() {
+  }
+}
+class ya extends ct {
+  /**
+   * 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 = ma(e));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: e } = this.node.getProps();
+    kt(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.call(this);
+  }
+}
+let ba = 0;
+class Ta extends ct {
+  constructor() {
+    super(...arguments), this.id = ba++;
+  }
+  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, onExitComplete: n } = this.node.presenceContext || {};
+    n && n(this.id), e && (this.unmount = e(this.id));
+  }
+  unmount() {
+  }
+}
+const va = {
+  animation: {
+    Feature: ya
+  },
+  exit: {
+    Feature: Ta
+  }
+};
+function vn(t, e, n, s = { passive: !0 }) {
+  return t.addEventListener(e, n, s), () => t.removeEventListener(e, n);
+}
+function _e(t) {
+  return {
+    point: {
+      x: t.pageX,
+      y: t.pageY
+    }
+  };
+}
+const sc = (t) => (e) => Cs(e) && t(e, _e(e));
+function wa({ top: t, left: e, right: n, bottom: s }) {
+  return {
+    x: { min: e, max: n },
+    y: { min: t, max: s }
+  };
+}
+function ic({ x: t, y: e }) {
+  return { top: e.min, right: t.max, bottom: e.max, left: t.min };
+}
+function xa(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
+  };
+}
+const wn = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), rc = () => ({
+  x: wn(),
+  y: wn()
+}), xn = () => ({ min: 0, max: 0 }), _s = () => ({
+  x: xn(),
+  y: xn()
+});
+function Ut(t) {
+  return t === void 0 || t === 1;
+}
+function Va({ scale: t, scaleX: e, scaleY: n }) {
+  return !Ut(t) || !Ut(e) || !Ut(n);
+}
+function Sa(t) {
+  return Va(t) || Aa(t) || t.z || t.rotate || t.rotateX || t.rotateY || t.skewX || t.skewY;
+}
+function Aa(t) {
+  return Vn(t.x) || Vn(t.y);
+}
+function Vn(t) {
+  return t && t !== "0%";
+}
+function Sn(t, e, n) {
+  const s = t - n, i = e * s;
+  return n + i;
+}
+function An(t, e, n, s, i) {
+  return i !== void 0 && (t = Sn(t, i, s)), Sn(t, n, s) + e;
+}
+function le(t, e = 0, n = 1, s, i) {
+  t.min = An(t.min, e, n, s, i), t.max = An(t.max, e, n, s, i);
+}
+function Ma(t, { x: e, y: n }) {
+  le(t.x, e.translate, e.scale, e.originPoint), le(t.y, n.translate, n.scale, n.originPoint);
+}
+const Mn = 0.999999999999, Cn = 1.0000000000001;
+function oc(t, e, n, s = !1) {
+  const i = n.length;
+  if (!i)
+    return;
+  e.x = e.y = 1;
+  let r, o;
+  for (let a = 0; a < i; a++) {
+    r = n[a], o = r.projectionDelta;
+    const { visualElement: u } = r.options;
+    u && u.props.style && u.props.style.display === "contents" || (s && r.options.layoutScroll && r.scroll && r !== r.root && Fn(t, {
+      x: -r.scroll.offset.x,
+      y: -r.scroll.offset.y
+    }), o && (e.x *= o.x.scale, e.y *= o.y.scale, Ma(t, o)), s && Sa(r.latestValues) && Fn(t, r.latestValues));
+  }
+  e.x < Cn && e.x > Mn && (e.x = 1), e.y < Cn && e.y > Mn && (e.y = 1);
+}
+function Pn(t, e) {
+  t.min = t.min + e, t.max = t.max + e;
+}
+function Dn(t, e, n, s, i = 0.5) {
+  const r = yt(t.min, t.max, i);
+  le(t, e, n, r, s);
+}
+function Fn(t, e) {
+  Dn(t.x, e.x, e.scaleX, e.scale, e.originX), Dn(t.y, e.y, e.scaleY, e.scale, e.originY);
+}
+function zs(t, e) {
+  return wa(xa(t.getBoundingClientRect(), e));
+}
+function ac(t, e, n) {
+  const s = zs(t, n), { scroll: i } = e;
+  return i && (Pn(s.x, i.offset.x), Pn(s.y, i.offset.y)), s;
+}
+function Rn(t, e, n) {
+  const { props: s } = t;
+  t.animationState && s.whileHover && t.animationState.setActive("whileHover", n === "Start");
+  const i = "onHover" + n, r = s[i];
+  r && k.postRender(() => r(e, _e(e)));
+}
+class Ca extends ct {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Xr(e, (n, s) => (Rn(this.node, s, "Start"), (i) => Rn(this.node, i, "End"))));
+  }
+  unmount() {
+  }
+}
+class Pa extends ct {
+  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 = Ot(vn(this.node.current, "focus", () => this.onFocus()), vn(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+function En(t, e, n) {
+  const { props: s } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled)
+    return;
+  t.animationState && s.whileTap && t.animationState.setActive("whileTap", n === "Start");
+  const i = "onTap" + (n === "End" ? "" : n), r = s[i];
+  r && k.postRender(() => r(e, _e(e)));
+}
+class Da extends ct {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Qr(e, (n, s) => (En(this.node, s, "Start"), (i, { success: r }) => En(this.node, i, r ? "End" : "Cancel")), { useGlobalTarget: this.node.props.globalTapTarget }));
+  }
+  unmount() {
+  }
+}
+const fe = /* @__PURE__ */ new WeakMap(), Gt = /* @__PURE__ */ new WeakMap(), Fa = (t) => {
+  const e = fe.get(t.target);
+  e && e(t);
+}, Ra = (t) => {
+  t.forEach(Fa);
+};
+function Ea({ root: t, ...e }) {
+  const n = t || document;
+  Gt.has(n) || Gt.set(n, {});
+  const s = Gt.get(n), i = JSON.stringify(e);
+  return s[i] || (s[i] = new IntersectionObserver(Ra, { root: t, ...e })), s[i];
+}
+function Oa(t, e, n) {
+  const s = Ea(e);
+  return fe.set(t, n), s.observe(t), () => {
+    fe.delete(t), s.unobserve(t);
+  };
+}
+const Ia = {
+  some: 0,
+  all: 1
+};
+class ka extends ct {
+  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 : Ia[i]
+    }, a = (u) => {
+      const { isIntersecting: l } = u;
+      if (this.isInView === l || (this.isInView = l, r && !l && this.hasEnteredView))
+        return;
+      l && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", l);
+      const { onViewportEnter: c, onViewportLeave: f } = this.node.getProps(), d = l ? c : f;
+      d && d(u);
+    };
+    return Oa(this.node.current, o, a);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: e, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(Na(e, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function Na({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (n) => t[n] !== e[n];
+}
+const La = {
+  inView: {
+    Feature: ka
+  },
+  tap: {
+    Feature: Da
+  },
+  focus: {
+    Feature: Pa
+  },
+  hover: {
+    Feature: Ca
+  }
+}, de = { current: null }, Us = { current: !1 };
+function Ba() {
+  if (Us.current = !0, !!ge)
+    if (window.matchMedia) {
+      const t = window.matchMedia("(prefers-reduced-motion)"), e = () => de.current = t.matches;
+      t.addListener(e), e();
+    } else
+      de.current = !1;
+}
+const Ka = /* @__PURE__ */ new WeakMap();
+function ja(t, e, n) {
+  for (const s in e) {
+    const i = e[s], r = n[s];
+    if (F(i))
+      t.addValue(s, i);
+    else if (F(r))
+      t.addValue(s, Dt(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, Dt(o !== void 0 ? o : i, { owner: t }));
+      }
+  }
+  for (const s in n)
+    e[s] === void 0 && t.removeValue(s);
+  return e;
+}
+const On = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class $a {
+  /**
+   * 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 }, a = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = Fe, 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 = I.now();
+      this.renderScheduledAt < d && (this.renderScheduledAt = d, k.render(this.render, !1, !0));
+    };
+    const { latestValues: u, renderState: l } = o;
+    this.latestValues = u, this.baseTarget = { ...u }, this.initialValues = n.initial ? { ...u } : {}, this.renderState = l, this.parent = e, this.props = n, this.presenceContext = s, this.depth = e ? e.depth + 1 : 0, this.reducedMotionConfig = i, this.options = a, this.blockInitialAnimation = !!r, this.isControllingVariants = Nt(n), this.isVariantNode = Ds(n), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(e && e.current);
+    const { willChange: c, ...f } = this.scrapeMotionValuesFromProps(n, {}, this);
+    for (const d in f) {
+      const h = f[d];
+      u[d] !== void 0 && F(h) && h.set(u[d], !1);
+    }
+  }
+  mount(e) {
+    this.current = e, Ka.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)), Us.current || Ba(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : de.current, process.env.NODE_ENV !== "production" && be(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() {
+    this.projection && this.projection.unmount(), Ht(this.notifyUpdate), Ht(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 = at.has(e);
+    s && this.onBindTransform && this.onBindTransform();
+    const i = n.on("change", (a) => {
+      this.latestValues[e] = a, this.props.onUpdate && k.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 tt) {
+      const n = tt[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) : _s();
+  }
+  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 < On.length; s++) {
+      const i = On[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 = ja(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 = Dt(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) {
+    let s = this.latestValues[e] !== void 0 || !this.current ? this.latestValues[e] : this.getBaseTargetFromProps(this.props, e) ?? this.readValueFromInstance(this.current, e, this.options);
+    return s != null && (typeof s == "string" && (Bn(s) || Kn(s)) ? s = parseFloat(s) : !eo(s) && rt.test(n) && (s = xs(e, n)), this.setBaseTarget(e, F(s) ? s.get() : s)), F(s) ? s.get() : s;
+  }
+  /**
+   * 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 r;
+    const { initial: n } = this.props;
+    let s;
+    if (typeof n == "string" || typeof n == "object") {
+      const o = $e(this.props, n, (r = this.presenceContext) == null ? void 0 : r.custom);
+      o && (s = o[e]);
+    }
+    if (n && s !== void 0)
+      return s;
+    const i = this.getBaseTargetFromProps(this.props, e);
+    return i !== void 0 && !F(i) ? i : this.initialValues[e] !== void 0 && s === void 0 ? void 0 : this.baseTarget[e];
+  }
+  on(e, n) {
+    return this.events[e] || (this.events[e] = new $n()), this.events[e].add(n);
+  }
+  notify(e, ...n) {
+    this.events[e] && this.events[e].notify(...n);
+  }
+}
+class Gs extends $a {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = zr;
+  }
+  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];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    F(e) && (this.childSubscription = e.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+function Hs(t, { style: e, vars: n }, s, i) {
+  Object.assign(t.style, e, i && i.getProjectionStyles(s));
+  for (const r in n)
+    t.style.setProperty(r, n[r]);
+}
+function Wa(t) {
+  return window.getComputedStyle(t);
+}
+class _a extends Gs {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = Hs;
+  }
+  readValueFromInstance(e, n) {
+    var s;
+    if (at.has(n))
+      return (s = this.projection) != null && s.isProjecting ? te(n) : cr(e, n);
+    {
+      const i = Wa(e), r = (we(n) ? i.getPropertyValue(n) : i[n]) || 0;
+      return typeof r == "string" ? r.trim() : r;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: n }) {
+    return zs(e, n);
+  }
+  build(e, n, s) {
+    Be(e, n, s.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, n, s) {
+    return We(e, n, s);
+  }
+}
+const Ys = /* @__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 za(t, e, n, s) {
+  Hs(t, e, void 0, s);
+  for (const i in e.attrs)
+    t.setAttribute(Ys.has(i) ? i : Le(i), e.attrs[i]);
+}
+class Ua extends Gs {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = _s;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e[n];
+  }
+  readValueFromInstance(e, n) {
+    if (at.has(n)) {
+      const s = ws(n);
+      return s && s.default || 0;
+    }
+    return n = Ys.has(n) ? n : Le(n), e.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(e, n, s) {
+    return Ks(e, n, s);
+  }
+  build(e, n, s) {
+    ks(e, n, this.isSVGTag, s.transformTemplate, s.style);
+  }
+  renderInstance(e, n, s, i) {
+    za(e, n, s, i);
+  }
+  mount(e) {
+    this.isSVGTag = Ls(e.tagName), super.mount(e);
+  }
+}
+const Ga = (t, e) => je(t) ? new Ua(e) : new _a(e, {
+  allowProjection: t !== kn
+}), Ha = {
+  renderer: Ga,
+  ...va,
+  ...La
+}, Ya = (t) => {
+  const { ripples: e = [], motionProps: n, color: s = "currentColor", style: i, onClear: r } = t;
+  return /* @__PURE__ */ O.jsx(O.Fragment, { children: e.map((o) => {
+    const a = ei(0.01 * o.size, 0.2, o.size > 100 ? 0.75 : 0.5);
+    return /* @__PURE__ */ O.jsx(co, { features: Ha, children: /* @__PURE__ */ O.jsx(ao, { mode: "popLayout", children: /* @__PURE__ */ O.jsx(
+      Uo.span,
+      {
+        animate: { transform: "scale(2)", opacity: 0 },
+        className: "ripple-item-span",
+        exit: { opacity: 0 },
+        initial: { transform: "scale(0)", opacity: 0.35 },
+        style: {
+          position: "absolute",
+          backgroundColor: s,
+          borderRadius: "100%",
+          transformOrigin: "center",
+          pointerEvents: "none",
+          overflow: "hidden",
+          inset: 0,
+          zIndex: 0,
+          top: o.y,
+          left: o.x,
+          width: `${o.size}px`,
+          height: `${o.size}px`,
+          ...i
+        },
+        transition: { duration: a },
+        onAnimationComplete: () => {
+          r(o.key);
+        },
+        ...n
+      }
+    ) }) }, o.key);
+  }) });
+};
+Ya.displayName = "LizaUI.Ripple";
+export {
+  Bo as $,
+  b as A,
+  rt as B,
+  oo as C,
+  nc as D,
+  Yr as E,
+  ct as F,
+  F as G,
+  Dt as H,
+  si as I,
+  ii as J,
+  I as K,
+  Nn as L,
+  li as M,
+  Sn as N,
+  $n as O,
+  ys as P,
+  ec as Q,
+  Ya as R,
+  To as S,
+  Sa as T,
+  Pn as U,
+  Fn as V,
+  Va as W,
+  Ma as X,
+  Aa as Y,
+  oc as Z,
+  rc as _,
+  ri as a,
+  ae as a0,
+  Zo as a1,
+  _o as a2,
+  Ga as a3,
+  La as a4,
+  va as a5,
+  ho as a6,
+  ao as a7,
+  vn as b,
+  sc as c,
+  k as d,
+  Cs as e,
+  At as f,
+  _e as g,
+  Ht as h,
+  fn as i,
+  K as j,
+  jn as k,
+  X as l,
+  yt as m,
+  _s as n,
+  Fs as o,
+  Ot as p,
+  W as q,
+  ac as r,
+  N as s,
+  ic as t,
+  tc as u,
+  wa as v,
+  qo as w,
+  oa as x,
+  Q as y,
+  st as z
+};
+//# sourceMappingURL=ripple-BQsLJHrx.js.map