@mobielnl/elements 0.12.23 → 0.12.25

package/dist/index-CSAejUDF.js

@@ -0,0 +1,1678 @@
+"use client";
+import { n as ne, i as Ot, a as z, m as ie, r as $e, h as je, b as Ft, w as se, c as Te, d as Ce, e as qe, f as de, g as De, t as L, j as Rt, k as H, l as E, o as $, p as Kt, s as R, v as Lt, M as j, W as ze, q as xe, N as Et, u as Bt, x as Gt, y as Nt, z as Ht, K as Xe, A as _t, B as Ae, C as Wt, D as Ut, E as $t, F as jt, G as Ye, H as qt, I as zt, J as Xt, L as Pe, O as ke, P as Y, Q as Ie, R as Yt, V as Zt, S as Jt, T as Qt, U as en, X as tn, Y as nn, Z as Ze, _ as sn, $ as rn, a0 as on, a1 as an, a2 as cn, a3 as Je, a4 as Qe, a5 as et, a6 as tt, a7 as ln } from "./index-BkgkTFrf.js";
+import { Fragment as un } from "react";
+var It = typeof globalThis < "u" && globalThis.process ? globalThis.process : { env: { NODE_ENV: "production" } };
+const re = (...t) => t.reduce((e, n) => (i) => n(e(i))), nt = /* @__NO_SIDE_EFFECTS__ */ (t, e, n) => {
+  const i = e - t;
+  return i ? (n - t) / i : 1;
+}, it = (t, e, n) => (((1 - 3 * n + 3 * e) * t + (3 * n - 6 * e)) * t + 3 * e) * t, fn = 1e-7, dn = 12;
+function hn(t, e, n, i, s) {
+  let r, a, o = 0;
+  do
+    a = e + (n - e) / 2, r = it(a, i, s) - t, r > 0 ? n = a : e = a;
+  while (Math.abs(r) > fn && ++o < dn);
+  return a;
+}
+// @__NO_SIDE_EFFECTS__
+function X(t, e, n, i) {
+  if (t === e && n === i)
+    return ne;
+  const s = (r) => hn(r, 0, 1, t, n);
+  return (r) => r === 0 || r === 1 ? r : it(s(r), e, i);
+}
+const st = /* @__NO_SIDE_EFFECTS__ */ (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, rt = /* @__NO_SIDE_EFFECTS__ */ (t) => (e) => 1 - t(1 - e), ot = /* @__PURE__ */ X(0.33, 1.53, 0.69, 0.99), we = /* @__PURE__ */ rt(ot), at = /* @__PURE__ */ st(we), ct = (t) => t >= 1 ? 1 : (t *= 2) < 1 ? 0.5 * we(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), Se = (t) => 1 - Math.sin(Math.acos(t)), mn = /* @__PURE__ */ rt(Se), lt = /* @__PURE__ */ st(Se), pn = /* @__PURE__ */ X(0.42, 0, 1, 1), gn = /* @__PURE__ */ X(0, 0, 0.58, 1), ut = /* @__PURE__ */ X(0.42, 0, 0.58, 1), yn = /* @__NO_SIDE_EFFECTS__ */ (t) => Array.isArray(t) && typeof t[0] != "number", Oe = {
+  linear: ne,
+  easeIn: pn,
+  easeInOut: ut,
+  easeOut: gn,
+  circIn: Se,
+  circInOut: lt,
+  circOut: mn,
+  backIn: we,
+  backInOut: at,
+  backOut: ot,
+  anticipate: ct
+}, vn = (t) => typeof t == "string", Fe = (t) => {
+  if (Ot(t)) {
+    z(t.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+    const [e, n, i, s] = t;
+    return /* @__PURE__ */ X(e, n, i, s);
+  } else if (vn(t))
+    return z(Oe[t] !== void 0, `Invalid easing type '${t}'`, "invalid-easing-type"), Oe[t];
+  return t;
+};
+function oe(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 bn({ hue: t, saturation: e, lightness: n, alpha: i }) {
+  t /= 360, e /= 100, n /= 100;
+  let s = 0, r = 0, a = 0;
+  if (!e)
+    s = r = a = n;
+  else {
+    const o = n < 0.5 ? n * (1 + e) : n + e - n * e, u = 2 * n - o;
+    s = oe(u, o, t + 1 / 3), r = oe(u, o, t), a = oe(u, o, t - 1 / 3);
+  }
+  return {
+    red: Math.round(s * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(a * 255),
+    alpha: i
+  };
+}
+function J(t, e) {
+  return (n) => n > 0 ? e : t;
+}
+const ae = (t, e, n) => {
+  const i = t * t, s = n * (e * e - i) + i;
+  return s < 0 ? 0 : Math.sqrt(s);
+}, Tn = [Ft, $e, je], xn = (t) => Tn.find((e) => e.test(t));
+function Re(t) {
+  const e = xn(t);
+  if (se(!!e, `'${t}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !e)
+    return !1;
+  let n = e.parse(t);
+  return e === je && (n = bn(n)), n;
+}
+const Ke = (t, e) => {
+  const n = Re(t), i = Re(e);
+  if (!n || !i)
+    return J(t, e);
+  const s = { ...n };
+  return (r) => (s.red = ae(n.red, i.red, r), s.green = ae(n.green, i.green, r), s.blue = ae(n.blue, i.blue, r), s.alpha = ie(n.alpha, i.alpha, r), $e.transform(s));
+}, he = /* @__PURE__ */ new Set(["none", "hidden"]);
+function An(t, e) {
+  return he.has(t) ? (n) => n <= 0 ? t : e : (n) => n >= 1 ? e : t;
+}
+function wn(t, e) {
+  return (n) => ie(t, e, n);
+}
+function Ve(t) {
+  return typeof t == "number" ? wn : typeof t == "string" ? Te(t) ? J : Ce.test(t) ? Ke : Mn : Array.isArray(t) ? ft : typeof t == "object" ? Ce.test(t) ? Ke : Sn : J;
+}
+function ft(t, e) {
+  const n = [...t], i = n.length, s = t.map((r, a) => Ve(r)(r, e[a]));
+  return (r) => {
+    for (let a = 0; a < i; a++)
+      n[a] = s[a](r);
+    return n;
+  };
+}
+function Sn(t, e) {
+  const n = { ...t, ...e }, i = {};
+  for (const s in n)
+    t[s] !== void 0 && e[s] !== void 0 && (i[s] = Ve(t[s])(t[s], e[s]));
+  return (s) => {
+    for (const r in i)
+      n[r] = i[r](s);
+    return n;
+  };
+}
+function Vn(t, e) {
+  const n = [], i = { color: 0, var: 0, number: 0 };
+  for (let s = 0; s < e.values.length; s++) {
+    const r = e.types[s], a = t.indexes[r][i[r]], o = t.values[a] ?? 0;
+    n[s] = o, i[r]++;
+  }
+  return n;
+}
+const Mn = (t, e) => {
+  const n = qe.createTransformer(e), i = de(t), s = de(e);
+  return i.indexes.var.length === s.indexes.var.length && i.indexes.color.length === s.indexes.color.length && i.indexes.number.length >= s.indexes.number.length ? he.has(t) && !s.values.length || he.has(e) && !i.values.length ? An(t, e) : re(ft(Vn(i, s), s.values), n) : (se(!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.`, "complex-values-different"), J(t, e));
+};
+function dt(t, e, n) {
+  return typeof t == "number" && typeof e == "number" && typeof n == "number" ? ie(t, e, n) : Ve(t)(t, e);
+}
+const Cn = (t) => {
+  const e = ({ timestamp: n }) => t(n);
+  return {
+    start: (n = !0) => H.update(e, n),
+    stop: () => Rt(e),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => De.isProcessing ? De.timestamp : L.now()
+  };
+}, Q = 2e4;
+function Me(t) {
+  let e = 0;
+  const n = 50;
+  let i = t.next(e);
+  for (; !i.done && e < Q; )
+    e += n, i = t.next(e);
+  return e >= Q ? 1 / 0 : e;
+}
+function Dn(t, e = 100, n) {
+  const i = n({ ...t, keyframes: [0, e] }), s = Math.min(Me(i), Q);
+  return {
+    type: "keyframes",
+    ease: (r) => i.next(s * r).value / e,
+    duration: E(s)
+  };
+}
+const S = {
+  // 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
+};
+function me(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const Pn = 12;
+function kn(t, e, n) {
+  let i = n;
+  for (let s = 1; s < Pn; s++)
+    i = i - t(i) / e(i);
+  return i;
+}
+const ce = 1e-3;
+function In({ duration: t = S.duration, bounce: e = S.bounce, velocity: n = S.velocity, mass: i = S.mass }) {
+  let s, r;
+  se(t <= R(S.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let a = 1 - e;
+  a = $(S.minDamping, S.maxDamping, a), t = $(S.minDuration, S.maxDuration, E(t)), a < 1 ? (s = (l) => {
+    const c = l * a, f = c * t, d = c - n, v = me(l, a), h = Math.exp(-f);
+    return ce - d / v * h;
+  }, r = (l) => {
+    const f = l * a * t, d = f * n + n, v = Math.pow(a, 2) * Math.pow(l, 2) * t, h = Math.exp(-f), p = me(Math.pow(l, 2), a);
+    return (-s(l) + ce > 0 ? -1 : 1) * ((d - v) * h) / p;
+  }) : (s = (l) => {
+    const c = Math.exp(-l * t), f = (l - n) * t + 1;
+    return -ce + c * f;
+  }, r = (l) => {
+    const c = Math.exp(-l * t), f = (n - l) * (t * t);
+    return c * f;
+  });
+  const o = 5 / t, u = kn(s, r, o);
+  if (t = R(t), isNaN(u))
+    return {
+      stiffness: S.stiffness,
+      damping: S.damping,
+      duration: t
+    };
+  {
+    const l = Math.pow(u, 2) * i;
+    return {
+      stiffness: l,
+      damping: a * 2 * Math.sqrt(i * l),
+      duration: t
+    };
+  }
+}
+const On = ["duration", "bounce"], Fn = ["stiffness", "damping", "mass"];
+function Le(t, e) {
+  return e.some((n) => t[n] !== void 0);
+}
+function Rn(t) {
+  let e = {
+    velocity: S.velocity,
+    stiffness: S.stiffness,
+    damping: S.damping,
+    mass: S.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!Le(t, Fn) && Le(t, On))
+    if (e.velocity = 0, t.visualDuration) {
+      const n = t.visualDuration, i = 2 * Math.PI / (n * 1.2), s = i * i, r = 2 * $(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(s);
+      e = {
+        ...e,
+        mass: S.mass,
+        stiffness: s,
+        damping: r
+      };
+    } else {
+      const n = In({ ...t, velocity: 0 });
+      e = {
+        ...e,
+        ...n,
+        mass: S.mass
+      }, e.isResolvedFromDuration = !0;
+    }
+  return e;
+}
+function ee(t = S.visualDuration, e = S.bounce) {
+  const n = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: e
+  } : t;
+  let { restSpeed: i, restDelta: s } = n;
+  const r = n.keyframes[0], a = n.keyframes[n.keyframes.length - 1], o = { done: !1, value: r }, { stiffness: u, damping: l, mass: c, duration: f, velocity: d, isResolvedFromDuration: v } = Rn({
+    ...n,
+    velocity: -E(n.velocity || 0)
+  }), h = d || 0, p = l / (2 * Math.sqrt(u * c)), m = a - r, g = E(Math.sqrt(u / c)), T = Math.abs(m) < 5;
+  i || (i = T ? S.restSpeed.granular : S.restSpeed.default), s || (s = T ? S.restDelta.granular : S.restDelta.default);
+  let A, w, x, V, C, b;
+  if (p < 1)
+    x = me(g, p), V = (h + p * g * m) / x, A = (y) => {
+      const M = Math.exp(-p * g * y);
+      return a - M * (V * Math.sin(x * y) + m * Math.cos(x * y));
+    }, C = p * g * V + m * x, b = p * g * m - V * x, w = (y) => Math.exp(-p * g * y) * (C * Math.sin(x * y) + b * Math.cos(x * y));
+  else if (p === 1) {
+    A = (M) => a - Math.exp(-g * M) * (m + (h + g * m) * M);
+    const y = h + g * m;
+    w = (M) => Math.exp(-g * M) * (g * y * M - h);
+  } else {
+    const y = g * Math.sqrt(p * p - 1);
+    A = (O) => {
+      const K = Math.exp(-p * g * O), F = Math.min(y * O, 300);
+      return a - K * ((h + p * g * m) * Math.sinh(F) + y * m * Math.cosh(F)) / y;
+    };
+    const M = (h + p * g * m) / y, k = p * g * M - m * y, B = p * g * m - M * y;
+    w = (O) => {
+      const K = Math.exp(-p * g * O), F = Math.min(y * O, 300);
+      return K * (k * Math.sinh(F) + B * Math.cosh(F));
+    };
+  }
+  const D = {
+    calculatedDuration: v && f || null,
+    velocity: (y) => R(w(y)),
+    next: (y) => {
+      if (!v && p < 1) {
+        const k = Math.exp(-p * g * y), B = Math.sin(x * y), O = Math.cos(x * y), K = a - k * (V * B + m * O), F = R(k * (C * B + b * O));
+        return o.done = Math.abs(F) <= i && Math.abs(a - K) <= s, o.value = o.done ? a : K, o;
+      }
+      const M = A(y);
+      if (v)
+        o.done = y >= f;
+      else {
+        const k = R(w(y));
+        o.done = Math.abs(k) <= i && Math.abs(a - M) <= s;
+      }
+      return o.value = o.done ? a : M, o;
+    },
+    toString: () => {
+      const y = Math.min(Me(D), Q), M = Kt((k) => D.next(y * k).value, y, 30);
+      return y + "ms " + M;
+    },
+    toTransition: () => {
+    }
+  };
+  return D;
+}
+ee.applyToOptions = (t) => {
+  const e = Dn(t, 100, ee);
+  return t.ease = e.ease, t.duration = R(e.duration), t.type = "keyframes", t;
+};
+const Kn = 5;
+function ht(t, e, n) {
+  const i = Math.max(e - Kn, 0);
+  return Lt(n - t(i), e - i);
+}
+function pe({ keyframes: t, velocity: e = 0, power: n = 0.8, timeConstant: i = 325, bounceDamping: s = 10, bounceStiffness: r = 500, modifyTarget: a, min: o, max: u, restDelta: l = 0.5, restSpeed: c }) {
+  const f = t[0], d = {
+    done: !1,
+    value: f
+  }, v = (b) => o !== void 0 && b < o || u !== void 0 && b > u, h = (b) => o === void 0 ? u : u === void 0 || Math.abs(o - b) < Math.abs(u - b) ? o : u;
+  let p = n * e;
+  const m = f + p, g = a === void 0 ? m : a(m);
+  g !== m && (p = g - f);
+  const T = (b) => -p * Math.exp(-b / i), A = (b) => g + T(b), w = (b) => {
+    const D = T(b), y = A(b);
+    d.done = Math.abs(D) <= l, d.value = d.done ? g : y;
+  };
+  let x, V;
+  const C = (b) => {
+    v(d.value) && (x = b, V = ee({
+      keyframes: [d.value, h(d.value)],
+      velocity: ht(A, b, d.value),
+      // TODO: This should be passing * 1000
+      damping: s,
+      stiffness: r,
+      restDelta: l,
+      restSpeed: c
+    }));
+  };
+  return C(0), {
+    calculatedDuration: null,
+    next: (b) => {
+      let D = !1;
+      return !V && x === void 0 && (D = !0, w(b), C(b)), x !== void 0 && b >= x ? V.next(b - x) : (!D && w(b), d);
+    }
+  };
+}
+function Ln(t, e, n) {
+  const i = [], s = n || j.mix || dt, r = t.length - 1;
+  for (let a = 0; a < r; a++) {
+    let o = s(t[a], t[a + 1]);
+    if (e) {
+      const u = Array.isArray(e) ? e[a] || ne : e;
+      o = re(u, o);
+    }
+    i.push(o);
+  }
+  return i;
+}
+function En(t, e, { clamp: n = !0, ease: i, mixer: s } = {}) {
+  const r = t.length;
+  if (z(r === e.length, "Both input and output ranges must be the same length", "range-length"), r === 1)
+    return () => e[0];
+  if (r === 2 && e[0] === e[1])
+    return () => e[1];
+  const a = t[0] === t[1];
+  t[0] > t[r - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const o = Ln(e, i, s), u = o.length, l = (c) => {
+    if (a && 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__ */ nt(t[f], t[f + 1], c);
+    return o[f](d);
+  };
+  return n ? (c) => l($(t[0], t[r - 1], c)) : l;
+}
+function Bn(t, e) {
+  const n = t[t.length - 1];
+  for (let i = 1; i <= e; i++) {
+    const s = /* @__PURE__ */ nt(0, e, i);
+    t.push(ie(n, 1, s));
+  }
+}
+function Gn(t) {
+  const e = [0];
+  return Bn(e, t.length - 1), e;
+}
+function Nn(t, e) {
+  return t.map((n) => n * e);
+}
+function Hn(t, e) {
+  return t.map(() => e || ut).splice(0, t.length - 1);
+}
+function W({ duration: t = 300, keyframes: e, times: n, ease: i = "easeInOut" }) {
+  const s = /* @__PURE__ */ yn(i) ? i.map(Fe) : Fe(i), r = {
+    done: !1,
+    value: e[0]
+  }, a = Nn(
+    // 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 : Gn(e),
+    t
+  ), o = En(a, e, {
+    ease: Array.isArray(s) ? s : Hn(e, s)
+  });
+  return {
+    calculatedDuration: t,
+    next: (u) => (r.value = o(u), r.done = u >= t, r)
+  };
+}
+const _n = {
+  decay: pe,
+  inertia: pe,
+  tween: W,
+  keyframes: W,
+  spring: ee
+};
+function mt(t) {
+  typeof t.type == "string" && (t.type = _n[t.type]);
+}
+const Wn = (t) => t / 100;
+class te extends ze {
+  constructor(e) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+      done: !1,
+      value: void 0
+    }, this.stop = () => {
+      const { motionValue: n } = this.options;
+      n && n.updatedAt !== L.now() && this.tick(L.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: e } = this;
+    mt(e);
+    const { type: n = W, repeat: i = 0, repeatDelay: s = 0, repeatType: r, velocity: a = 0 } = e;
+    let { keyframes: o } = e;
+    const u = n || W;
+    It.env.NODE_ENV !== "production" && u !== W && z(o.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${o}`, "spring-two-frames"), u !== W && typeof o[0] != "number" && (this.mixKeyframes = re(Wn, dt(o[0], o[1])), o = [0, 100]);
+    const l = u({ ...e, keyframes: o });
+    r === "mirror" && (this.mirroredGenerator = u({
+      ...e,
+      keyframes: [...o].reverse(),
+      velocity: -a
+    })), l.calculatedDuration === null && (l.calculatedDuration = Me(l));
+    const { calculatedDuration: c } = l;
+    this.calculatedDuration = c, this.resolvedDuration = c + s, this.totalDuration = this.resolvedDuration * (i + 1) - s, 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: i, totalDuration: s, mixKeyframes: r, mirroredGenerator: a, resolvedDuration: o, calculatedDuration: u } = this;
+    if (this.startTime === null)
+      return i.next(0);
+    const { delay: l = 0, keyframes: c, repeat: f, repeatType: d, repeatDelay: v, type: h, onUpdate: p, finalKeyframe: m } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - s / this.speed, this.startTime)), n ? this.currentTime = e : this.updateTime(e);
+    const g = this.currentTime - l * (this.playbackSpeed >= 0 ? 1 : -1), T = this.playbackSpeed >= 0 ? g < 0 : g > s;
+    this.currentTime = Math.max(g, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
+    let A = this.currentTime, w = i;
+    if (f) {
+      const b = Math.min(this.currentTime, s) / o;
+      let D = Math.floor(b), y = b % 1;
+      !y && b >= 1 && (y = 1), y === 1 && D--, D = Math.min(D, f + 1), D % 2 && (d === "reverse" ? (y = 1 - y, v && (y -= v / o)) : d === "mirror" && (w = a)), A = $(0, 1, y) * o;
+    }
+    let x;
+    T ? (this.delayState.value = c[0], x = this.delayState) : x = w.next(A), r && !T && (x.value = r(x.value));
+    let { done: V } = x;
+    !T && u !== null && (V = this.playbackSpeed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
+    const C = this.holdTime === null && (this.state === "finished" || this.state === "running" && V);
+    return C && h !== pe && (x.value = xe(c, this.options, m, this.speed)), p && p(x.value), C && this.finish(), x;
+  }
+  /**
+   * 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 E(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: e = 0 } = this.options || {};
+    return this.duration + E(e);
+  }
+  get time() {
+    return E(this.currentTime);
+  }
+  set time(e) {
+    e = R(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), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = e, this.tick(e));
+  }
+  /**
+   * Returns the generator's velocity at the current time in units/second.
+   * Uses the analytical derivative when available (springs), avoiding
+   * the MotionValue's frame-dependent velocity estimation.
+   */
+  getGeneratorVelocity() {
+    const e = this.currentTime;
+    if (e <= 0)
+      return this.options.velocity || 0;
+    if (this.generator.velocity)
+      return this.generator.velocity(e);
+    const n = this.generator.next(e).value;
+    return ht((i) => this.generator.next(i).value, e, n);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(e) {
+    const n = this.playbackSpeed !== e;
+    n && this.driver && this.updateTime(L.now()), this.playbackSpeed = e, n && this.driver && (this.time = E(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: e = Cn, startTime: n } = this.options;
+    this.driver || (this.driver = e((s) => this.tick(s))), this.options.onPlay?.();
+    const i = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = i) : this.holdTime !== null ? this.startTime = i - this.holdTime : this.startTime || (this.startTime = n ?? i), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(L.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(e) {
+    return this.startTime = 0, this.tick(e, !0);
+  }
+  attachTimeline(e) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), e.observe(this);
+  }
+}
+const pt = {
+  anticipate: ct,
+  backInOut: at,
+  circInOut: lt
+};
+function Un(t) {
+  return t in pt;
+}
+function $n(t) {
+  typeof t.ease == "string" && Un(t.ease) && (t.ease = pt[t.ease]);
+}
+const le = 10;
+class jn extends Et {
+  constructor(e) {
+    $n(e), mt(e), super(e), e.startTime !== void 0 && e.autoplay !== !1 && (this.startTime = e.startTime), this.options = e;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read committed styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
+   */
+  updateMotionValue(e) {
+    const { motionValue: n, onUpdate: i, onComplete: s, element: r, ...a } = this.options;
+    if (!n)
+      return;
+    if (e !== void 0) {
+      n.set(e);
+      return;
+    }
+    const o = new te({
+      ...a,
+      autoplay: !1
+    }), u = Math.max(le, L.now() - this.startTime), l = $(0, le, u - le), c = o.sample(u).value, { name: f } = this.options;
+    r && f && Bt(r, f, c), n.setWithVelocity(o.sample(Math.max(0, u - l)).value, c, l), o.stop();
+  }
+}
+const Ee = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(qe.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url("));
+function qn(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 zn(t, e, n, i) {
+  const s = t[0];
+  if (s === null)
+    return !1;
+  if (e === "display" || e === "visibility")
+    return !0;
+  const r = t[t.length - 1], a = Ee(s, e), o = Ee(r, e);
+  return se(a === o, `You are trying to animate ${e} from "${s}" to "${r}". "${a ? r : s}" is not an animatable value.`, "value-not-animatable"), !a || !o ? !1 : qn(t) || (n === "spring" || Gt(n)) && i;
+}
+function ge(t) {
+  t.duration = 0, t.type = "keyframes";
+}
+const Xn = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/;
+function Yn(t) {
+  for (let e = 0; e < t.length; e++)
+    if (typeof t[e] == "string" && Xn.test(t[e]))
+      return !0;
+  return !1;
+}
+const Zn = /* @__PURE__ */ new Set([
+  "color",
+  "backgroundColor",
+  "outlineColor",
+  "fill",
+  "stroke",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor"
+]), Jn = /* @__PURE__ */ Ht(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function Qn(t) {
+  const { motionValue: e, name: n, repeatDelay: i, repeatType: s, damping: r, type: a, keyframes: o } = t;
+  if (!(e?.owner?.current instanceof HTMLElement))
+    return !1;
+  const { onUpdate: l, transformTemplate: c } = e.owner.getProps();
+  return Jn() && n && /**
+   * Force WAAPI for color properties with browser-only color formats
+   * (oklch, oklab, lab, lch, etc.) that the JS animation path can't parse.
+   */
+  (Nt.has(n) || Zn.has(n) && Yn(o)) && (n !== "transform" || !c) && /**
+   * 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.
+   */
+  !l && !i && s !== "mirror" && r !== 0 && a !== "inertia";
+}
+const ei = 40;
+class ti extends ze {
+  constructor({ autoplay: e = !0, delay: n = 0, type: i = "keyframes", repeat: s = 0, repeatDelay: r = 0, repeatType: a = "loop", keyframes: o, name: u, motionValue: l, element: c, ...f }) {
+    super(), this.stop = () => {
+      this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+    }, this.createdAt = L.now();
+    const d = {
+      autoplay: e,
+      delay: n,
+      type: i,
+      repeat: s,
+      repeatDelay: r,
+      repeatType: a,
+      name: u,
+      motionValue: l,
+      element: c,
+      ...f
+    }, v = c?.KeyframeResolver || Xe;
+    this.keyframeResolver = new v(o, (h, p, m) => this.onKeyframesResolved(h, p, d, !m), u, l, c), this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(e, n, i, s) {
+    this.keyframeResolver = void 0;
+    const { name: r, type: a, velocity: o, delay: u, isHandoff: l, onUpdate: c } = i;
+    this.resolvedAt = L.now();
+    let f = !0;
+    zn(e, r, a, o) || (f = !1, (j.instantAnimations || !u) && c?.(xe(e, i, n)), e[0] = e[e.length - 1], ge(i), i.repeat = 0);
+    const v = {
+      startTime: s ? this.resolvedAt ? this.resolvedAt - this.createdAt > ei ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: n,
+      ...i,
+      keyframes: e
+    }, h = f && !l && Qn(v), p = v.motionValue?.owner?.current;
+    let m;
+    if (h)
+      try {
+        m = new jn({
+          ...v,
+          element: p
+        });
+      } catch {
+        m = new te(v);
+      }
+    else
+      m = new te(v);
+    m.finished.then(() => {
+      this.notifyFinished();
+    }).catch(ne), this.pendingTimeline && (this.stopTimeline = m.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = m;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(e, n) {
+    return this.finished.finally(e).then(() => {
+    });
+  }
+  get animation() {
+    return this._animation || (this.keyframeResolver?.resume(), _t()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  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() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+  }
+}
+function gt(t, e, n, i = 0, s = 1) {
+  const r = Array.from(t).sort((l, c) => l.sortNodePosition(c)).indexOf(e), a = t.size, o = (a - 1) * i;
+  return typeof n == "function" ? n(r, a) : s === 1 ? r * i : o - r * i;
+}
+function yt(t, e) {
+  if (t?.inherit && e) {
+    const { inherit: n, ...i } = t;
+    return { ...e, ...i };
+  }
+  return t;
+}
+function vt(t, e) {
+  const n = t?.[e] ?? t?.default ?? t;
+  return n !== t ? yt(n, t) : n;
+}
+const ni = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, ii = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), si = {
+  type: "keyframes",
+  duration: 0.8
+}, ri = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, oi = (t, { keyframes: e }) => e.length > 2 ? si : Ae.has(t) ? t.startsWith("scale") ? ii(e[1]) : ni : ri, ai = /* @__PURE__ */ new Set([
+  "when",
+  "delay",
+  "delayChildren",
+  "staggerChildren",
+  "staggerDirection",
+  "repeat",
+  "repeatType",
+  "repeatDelay",
+  "from",
+  "elapsed"
+]);
+function ci(t) {
+  for (const e in t)
+    if (!ai.has(e))
+      return !0;
+  return !1;
+}
+const li = (t, e, n, i = {}, s, r) => (a) => {
+  const o = vt(i, t) || {}, u = o.delay || i.delay || 0;
+  let { elapsed: l = 0 } = i;
+  l = l - R(u);
+  const c = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...o,
+    delay: -l,
+    onUpdate: (d) => {
+      e.set(d), o.onUpdate && o.onUpdate(d);
+    },
+    onComplete: () => {
+      a(), o.onComplete && o.onComplete();
+    },
+    name: t,
+    motionValue: e,
+    element: r ? void 0 : s
+  };
+  ci(o) || Object.assign(c, oi(t, c)), c.duration && (c.duration = R(c.duration)), c.repeatDelay && (c.repeatDelay = R(c.repeatDelay)), c.from !== void 0 && (c.keyframes[0] = c.from);
+  let f = !1;
+  if ((c.type === !1 || c.duration === 0 && !c.repeatDelay) && (ge(c), c.delay === 0 && (f = !0)), (j.instantAnimations || j.skipAnimations || s?.shouldSkipAnimations || o.skipAnimations) && (f = !0, ge(c), c.delay = 0), c.allowFlatten = !o.type && !o.ease, f && !r && e.get() !== void 0) {
+    const d = xe(c.keyframes, o);
+    if (d !== void 0) {
+      H.update(() => {
+        c.onUpdate(d), c.onComplete();
+      });
+      return;
+    }
+  }
+  return o.isSync ? new te(c) : new ti(c);
+}, ui = (
+  // 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 fi(t) {
+  const e = ui.exec(t);
+  if (!e)
+    return [,];
+  const [, n, i, s] = e;
+  return [`--${n ?? i}`, s];
+}
+const di = 4;
+function bt(t, e, n = 1) {
+  z(n <= di, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [i, s] = fi(t);
+  if (!i)
+    return;
+  const r = window.getComputedStyle(e).getPropertyValue(i);
+  if (r) {
+    const a = r.trim();
+    return Wt(a) ? parseFloat(a) : a;
+  }
+  return Te(s) ? bt(s, e, n + 1) : s;
+}
+function U(t, e, n) {
+  const i = t.getProps();
+  return Ut(i, e, n !== void 0 ? n : i.custom, t);
+}
+const Tt = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...$t
+]), ye = (t) => Array.isArray(t);
+function hi(t, e, n) {
+  t.hasValue(e) ? t.getValue(e).set(n) : t.addValue(e, jt(n));
+}
+function mi(t) {
+  return ye(t) ? t[t.length - 1] || 0 : t;
+}
+function pi(t, e) {
+  const n = U(t, e);
+  let { transitionEnd: i = {}, transition: s = {}, ...r } = n || {};
+  r = { ...r, ...i };
+  for (const a in r) {
+    const o = mi(r[a]);
+    hi(t, a, o);
+  }
+}
+function gi(t) {
+  return !!(Ye(t) && t.add);
+}
+function yi(t, e) {
+  const n = t.getValue("willChange");
+  if (gi(n))
+    return n.add(e);
+  if (!n && j.WillChange) {
+    const i = new j.WillChange("auto");
+    t.addValue("willChange", i), i.add(e);
+  }
+}
+function vi(t) {
+  return t.props[qt];
+}
+function bi({ protectedKeys: t, needsAnimating: e }, n) {
+  const i = t.hasOwnProperty(n) && e[n] !== !0;
+  return e[n] = !1, i;
+}
+function xt(t, e, { delay: n = 0, transitionOverride: i, type: s } = {}) {
+  let { transition: r, transitionEnd: a, ...o } = e;
+  const u = t.getDefaultTransition();
+  r = r ? yt(r, u) : u;
+  const l = r?.reduceMotion, c = r?.skipAnimations;
+  i && (r = i);
+  const f = [], d = s && t.animationState && t.animationState.getState()[s], v = r?.path;
+  v && v.animateVisualElement(t, o, r, n, f);
+  for (const h in o) {
+    const p = t.getValue(h, t.latestValues[h] ?? null), m = o[h];
+    if (m === void 0 || d && bi(d, h))
+      continue;
+    const g = {
+      delay: n,
+      ...vt(r || {}, h)
+    };
+    c && (g.skipAnimations = !0);
+    const T = p.get();
+    if (T !== void 0 && !p.isAnimating() && !Array.isArray(m) && m === T && !g.velocity) {
+      H.update(() => p.set(m));
+      continue;
+    }
+    let A = !1;
+    if (window.MotionHandoffAnimation) {
+      const V = vi(t);
+      if (V) {
+        const C = window.MotionHandoffAnimation(V, h, H);
+        C !== null && (g.startTime = C, A = !0);
+      }
+    }
+    yi(t, h);
+    const w = l ?? t.shouldReduceMotion;
+    p.start(li(h, p, m, w && Tt.has(h) ? { type: !1 } : g, t, A));
+    const x = p.animation;
+    x && f.push(x);
+  }
+  if (a) {
+    const h = () => H.update(() => {
+      a && pi(t, a);
+    });
+    f.length ? Promise.all(f).then(h) : h();
+  }
+  return f;
+}
+function ve(t, e, n = {}) {
+  const i = U(t, e, n.type === "exit" ? t.presenceContext?.custom : void 0);
+  let { transition: s = t.getDefaultTransition() || {} } = i || {};
+  n.transitionOverride && (s = n.transitionOverride);
+  const r = i ? () => Promise.all(xt(t, i, n)) : () => Promise.resolve(), a = t.variantChildren && t.variantChildren.size ? (u = 0) => {
+    const { delayChildren: l = 0, staggerChildren: c, staggerDirection: f } = s;
+    return Ti(t, e, u, l, c, f, n);
+  } : () => Promise.resolve(), { when: o } = s;
+  if (o) {
+    const [u, l] = o === "beforeChildren" ? [r, a] : [a, r];
+    return u().then(() => l());
+  } else
+    return Promise.all([r(), a(n.delay)]);
+}
+function Ti(t, e, n = 0, i = 0, s = 0, r = 1, a) {
+  const o = [];
+  for (const u of t.variantChildren)
+    u.notify("AnimationStart", e), o.push(ve(u, e, {
+      ...a,
+      delay: n + (typeof i == "function" ? 0 : i) + gt(t.variantChildren, u, i, s, r)
+    }).then(() => u.notify("AnimationComplete", e)));
+  return Promise.all(o);
+}
+function xi(t, e, n = {}) {
+  t.notify("AnimationStart", e);
+  let i;
+  if (Array.isArray(e)) {
+    const s = e.map((r) => ve(t, r, n));
+    i = Promise.all(s);
+  } else if (typeof e == "string")
+    i = ve(t, e, n);
+  else {
+    const s = typeof e == "function" ? U(t, e, n.custom) : e;
+    i = Promise.all(xt(t, s, n));
+  }
+  return i.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+function Ai(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || zt(t) : !0;
+}
+const wi = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function Si(t, e, n) {
+  let i = 0, s;
+  for (; i < t.length && !s; ) {
+    const r = t[i];
+    typeof r == "string" && !wi.has(r) && de(r).values.length && (s = t[i]), i++;
+  }
+  if (s && n)
+    for (const r of e)
+      t[r] = Xt(n, s);
+}
+class Vi extends Xe {
+  constructor(e, n, i, s, r) {
+    super(e, n, i, s, r, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: n, name: i } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let c = 0; c < e.length; c++) {
+      let f = e[c];
+      if (typeof f == "string" && (f = f.trim(), Te(f))) {
+        const d = bt(f, n.current);
+        d !== void 0 && (e[c] = d), c === e.length - 1 && (this.finalKeyframe = f);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !Tt.has(i) || e.length !== 2)
+      return;
+    const [s, r] = e, a = Pe(s), o = Pe(r), u = ke(s), l = ke(r);
+    if (u !== l && Y[i]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (a !== o)
+      if (Ie(a) && Ie(o))
+        for (let c = 0; c < e.length; c++) {
+          const f = e[c];
+          typeof f == "string" && (e[c] = parseFloat(f));
+        }
+      else Y[i] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, i = [];
+    for (let s = 0; s < e.length; s++)
+      (e[s] === null || Ai(e[s])) && i.push(s);
+    i.length && Si(e, i, n);
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: n, name: i } = this;
+    if (!e || !e.current)
+      return;
+    i === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = Y[i](e.measureViewportBox(), window.getComputedStyle(e.current)), n[0] = this.measuredOrigin;
+    const s = n[n.length - 1];
+    s !== void 0 && e.getValue(i, s).jump(s, !1);
+  }
+  measureEndState() {
+    const { element: e, name: n, unresolvedKeyframes: i } = this;
+    if (!e || !e.current)
+      return;
+    const s = e.getValue(n);
+    s && s.jump(this.measuredOrigin, !1);
+    const r = i.length - 1, a = i[r];
+    i[r] = Y[n](e.measureViewportBox(), window.getComputedStyle(e.current)), a !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = a), this.removedTransforms?.length && this.removedTransforms.forEach(([o, u]) => {
+      e.getValue(o).set(u);
+    }), this.resolveNoneKeyframes();
+  }
+}
+function Mi(t, e, n) {
+  if (t == null)
+    return [];
+  if (t instanceof EventTarget)
+    return [t];
+  if (typeof t == "string") {
+    let i = document;
+    const s = n?.[t] ?? i.querySelectorAll(t);
+    return s ? Array.from(s) : [];
+  }
+  return Array.from(t).filter((i) => i != null);
+}
+const Ci = {
+  y: !1
+};
+function Di() {
+  return Ci.y;
+}
+function At(t, e) {
+  const n = Mi(t), i = new AbortController(), s = {
+    passive: !0,
+    ...e,
+    signal: i.signal
+  };
+  return [n, s, () => i.abort()];
+}
+function Pi(t) {
+  return !(t.pointerType === "touch" || Di());
+}
+function ki(t, e, n = {}) {
+  const [i, s, r] = At(t, n);
+  return i.forEach((a) => {
+    let o = !1, u = !1, l;
+    const c = () => {
+      a.removeEventListener("pointerleave", h);
+    }, f = (m) => {
+      l && (l(m), l = void 0), c();
+    }, d = (m) => {
+      o = !1, window.removeEventListener("pointerup", d), window.removeEventListener("pointercancel", d), u && (u = !1, f(m));
+    }, v = () => {
+      o = !0, window.addEventListener("pointerup", d, s), window.addEventListener("pointercancel", d, s);
+    }, h = (m) => {
+      if (m.pointerType !== "touch") {
+        if (o) {
+          u = !0;
+          return;
+        }
+        f(m);
+      }
+    }, p = (m) => {
+      if (!Pi(m))
+        return;
+      u = !1;
+      const g = e(a, m);
+      typeof g == "function" && (l = g, a.addEventListener("pointerleave", h, s));
+    };
+    a.addEventListener("pointerenter", p, s), a.addEventListener("pointerdown", v, s);
+  }), r;
+}
+const wt = (t, e) => e ? t === e ? !0 : wt(t, e.parentElement) : !1, Ii = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, Oi = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function Fi(t) {
+  return Oi.has(t.tagName) || t.isContentEditable === !0;
+}
+const Z = /* @__PURE__ */ new WeakSet();
+function Be(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function ue(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
+}
+const Ri = (t, e) => {
+  const n = t.currentTarget;
+  if (!n)
+    return;
+  const i = Be(() => {
+    if (Z.has(n))
+      return;
+    ue(n, "down");
+    const s = Be(() => {
+      ue(n, "up");
+    }), r = () => ue(n, "cancel");
+    n.addEventListener("keyup", s, e), n.addEventListener("blur", r, e);
+  });
+  n.addEventListener("keydown", i, e), n.addEventListener("blur", () => n.removeEventListener("keydown", i), e);
+};
+function Ge(t) {
+  return Ii(t) && !0;
+}
+const Ne = /* @__PURE__ */ new WeakSet();
+function Ki(t, e, n = {}) {
+  const [i, s, r] = At(t, n), a = (o) => {
+    const u = o.currentTarget;
+    if (!Ge(o) || Ne.has(o))
+      return;
+    Z.add(u), n.stopPropagation && Ne.add(o);
+    const l = e(u, o), c = { ...s, capture: !0 }, f = (h, p) => {
+      window.removeEventListener("pointerup", d, c), window.removeEventListener("pointercancel", v, c), Z.has(u) && Z.delete(u), Ge(h) && typeof l == "function" && l(h, { success: p });
+    }, d = (h) => {
+      f(h, u === window || u === document || n.useGlobalTarget || wt(u, h.target));
+    }, v = (h) => {
+      f(h, !1);
+    };
+    window.addEventListener("pointerup", d, c), window.addEventListener("pointercancel", v, c);
+  };
+  return i.forEach((o) => {
+    (n.useGlobalTarget ? window : o).addEventListener("pointerdown", a, s), Yt(o) && (o.addEventListener("focus", (l) => Ri(l, s)), !Fi(o) && !o.hasAttribute("tabindex") && (o.tabIndex = 0));
+  }), r;
+}
+class St extends Zt {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = Vi;
+  }
+  sortInstanceNodePosition(e, n) {
+    return e.compareDocumentPosition(n) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, n) {
+    const i = e.style;
+    return i ? i[n] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: n, style: i }) {
+    delete n[e], delete i[e];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    Ye(e) && (this.childSubscription = e.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+class q {
+  constructor(e) {
+    this.isMounted = !1, this.node = e;
+  }
+  update() {
+  }
+}
+function Li({ top: t, left: e, right: n, bottom: i }) {
+  return {
+    x: { min: e, max: n },
+    y: { min: t, max: i }
+  };
+}
+function Ei(t, e) {
+  if (!e)
+    return t;
+  const n = e({ x: t.left, y: t.top }), i = e({ x: t.right, y: t.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: i.y,
+    right: i.x
+  };
+}
+function Bi(t, e) {
+  return Li(Ei(t.getBoundingClientRect(), e));
+}
+function Vt(t, { style: e, vars: n }, i, s) {
+  const r = t.style;
+  let a;
+  for (a in e)
+    r[a] = e[a];
+  s?.applyProjectionStyles(r, i);
+  for (a in n)
+    r.setProperty(a, n[a]);
+}
+function Gi(t) {
+  return window.getComputedStyle(t);
+}
+class Ni extends St {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = Vt;
+  }
+  readValueFromInstance(e, n) {
+    if (Ae.has(n))
+      return this.projection?.isProjecting ? Jt(n) : Qt(e, n);
+    {
+      const i = Gi(e), s = (en(n) ? i.getPropertyValue(n) : i[n]) || 0;
+      return typeof s == "string" ? s.trim() : s;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: n }) {
+    return Bi(e, n);
+  }
+  build(e, n, i) {
+    tn(e, n, i.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, n, i) {
+    return nn(e, n, i);
+  }
+}
+const Mt = /* @__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 Hi(t, e, n, i) {
+  Vt(t, e, void 0, i);
+  for (const s in e.attrs)
+    t.setAttribute(Mt.has(s) ? s : Ze(s), e.attrs[s]);
+}
+class _i extends St {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = sn;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e[n];
+  }
+  readValueFromInstance(e, n) {
+    if (Ae.has(n)) {
+      const i = cn(n);
+      return i && i.default || 0;
+    }
+    return n = Mt.has(n) ? n : Ze(n), e.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(e, n, i) {
+    return rn(e, n, i);
+  }
+  build(e, n, i) {
+    on(e, n, this.isSVGTag, i.transformTemplate, i.style);
+  }
+  renderInstance(e, n, i, s) {
+    Hi(e, n, i, s);
+  }
+  mount(e) {
+    this.isSVGTag = an(e.tagName), super.mount(e);
+  }
+}
+const Wi = Qe.length;
+function Ct(t) {
+  if (!t)
+    return;
+  if (!t.isControllingVariants) {
+    const n = t.parent ? Ct(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (n.initial = t.props.initial), n;
+  }
+  const e = {};
+  for (let n = 0; n < Wi; n++) {
+    const i = Qe[n], s = t.props[i];
+    (Je(s) || s === !1) && (e[i] = s);
+  }
+  return e;
+}
+function Dt(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let i = 0; i < n; i++)
+    if (e[i] !== t[i])
+      return !1;
+  return !0;
+}
+const Ui = [...tt].reverse(), $i = tt.length;
+function ji(t) {
+  return (e) => Promise.all(e.map(({ animation: n, options: i }) => xi(t, n, i)));
+}
+function qi(t) {
+  let e = ji(t), n = He(), i = !0, s = !1;
+  const r = (l) => (c, f) => {
+    const d = U(t, f, l === "exit" ? t.presenceContext?.custom : void 0);
+    if (d) {
+      const { transition: v, transitionEnd: h, ...p } = d;
+      c = { ...c, ...p, ...h };
+    }
+    return c;
+  };
+  function a(l) {
+    e = l(t);
+  }
+  function o(l) {
+    const { props: c } = t, f = Ct(t.parent) || {}, d = [], v = /* @__PURE__ */ new Set();
+    let h = {}, p = 1 / 0;
+    for (let g = 0; g < $i; g++) {
+      const T = Ui[g], A = n[T], w = c[T] !== void 0 ? c[T] : f[T], x = Je(w), V = T === l ? A.isActive : null;
+      V === !1 && (p = g);
+      let C = w === f[T] && w !== c[T] && x;
+      if (C && (i || s) && t.manuallyAnimateOnMount && (C = !1), A.protectedKeys = { ...h }, // If it isn't active and hasn't *just* been set as inactive
+      !A.isActive && V === null || // If we didn't and don't have any defined prop for this animation type
+      !w && !A.prevProp || // Or if the prop doesn't define an animation
+      et(w) || typeof w == "boolean")
+        continue;
+      if (T === "exit" && A.isActive && V !== !0) {
+        A.prevResolvedValues && (h = {
+          ...h,
+          ...A.prevResolvedValues
+        });
+        continue;
+      }
+      const b = zi(A.prevProp, w);
+      let D = b || // If we're making this variant active, we want to always make it active
+      T === l && A.isActive && !C && x || // If we removed a higher-priority variant (i is in reverse order)
+      g > p && x, y = !1;
+      const M = Array.isArray(w) ? w : [w];
+      let k = M.reduce(r(T), {});
+      V === !1 && (k = {});
+      const { prevResolvedValues: B = {} } = A, O = {
+        ...B,
+        ...k
+      }, K = (P) => {
+        D = !0, v.has(P) && (y = !0, v.delete(P)), A.needsAnimating[P] = !0;
+        const I = t.getValue(P);
+        I && (I.liveStyle = !1);
+      };
+      for (const P in O) {
+        const I = k[P], G = B[P];
+        if (h.hasOwnProperty(P))
+          continue;
+        let _ = !1;
+        ye(I) && ye(G) ? _ = !Dt(I, G) || b : _ = I !== G, _ ? I != null ? K(P) : v.add(P) : I !== void 0 && v.has(P) ? K(P) : A.protectedKeys[P] = !0;
+      }
+      A.prevProp = w, A.prevResolvedValues = k, A.isActive && (h = { ...h, ...k }), (i || s) && t.blockInitialAnimation && (D = !1);
+      const F = C && b;
+      D && (!F || y) && d.push(...M.map((P) => {
+        const I = { type: T };
+        if (typeof P == "string" && (i || s) && !F && t.manuallyAnimateOnMount && t.parent) {
+          const { parent: G } = t, _ = U(G, P);
+          if (G.enteringChildren && _) {
+            const { delayChildren: kt } = _.transition || {};
+            I.delay = gt(G.enteringChildren, t, kt);
+          }
+        }
+        return {
+          animation: P,
+          options: I
+        };
+      }));
+    }
+    if (v.size) {
+      const g = {};
+      if (typeof c.initial != "boolean") {
+        const T = U(t, Array.isArray(c.initial) ? c.initial[0] : c.initial);
+        T && T.transition && (g.transition = T.transition);
+      }
+      v.forEach((T) => {
+        const A = t.getBaseTarget(T), w = t.getValue(T);
+        w && (w.liveStyle = !0), g[T] = A ?? null;
+      }), d.push({ animation: g });
+    }
+    let m = !!d.length;
+    return i && (c.initial === !1 || c.initial === c.animate) && !t.manuallyAnimateOnMount && (m = !1), i = !1, s = !1, m ? e(d) : Promise.resolve();
+  }
+  function u(l, c) {
+    if (n[l].isActive === c)
+      return Promise.resolve();
+    t.variantChildren?.forEach((d) => d.animationState?.setActive(l, c)), n[l].isActive = c;
+    const f = o(l);
+    for (const d in n)
+      n[d].protectedKeys = {};
+    return f;
+  }
+  return {
+    animateChanges: o,
+    setActive: u,
+    setAnimateFunction: a,
+    getState: () => n,
+    reset: () => {
+      n = He(), s = !0;
+    }
+  };
+}
+function zi(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !Dt(e, t) : !1;
+}
+function N(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function He() {
+  return {
+    animate: N(!0),
+    whileInView: N(),
+    whileHover: N(),
+    whileTap: N(),
+    whileDrag: N(),
+    whileFocus: N(),
+    exit: N()
+  };
+}
+function _e(t, e, n, i = { passive: !0 }) {
+  return t.addEventListener(e, n, i), () => t.removeEventListener(e, n, i);
+}
+const Xi = (t, e) => e.isSVG ?? ln(t) ? new _i(e) : new Ni(e, {
+  allowProjection: t !== un
+});
+class Yi extends q {
+  /**
+   * 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 = qi(e));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: e } = this.node.getProps();
+    et(e) && (this.unmountControls = e.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: e } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    e !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    this.node.animationState.reset(), this.unmountControls?.();
+  }
+}
+let Zi = 0;
+class Ji extends q {
+  constructor() {
+    super(...arguments), this.id = Zi++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: e, onExitComplete: n } = this.node.presenceContext, { isPresent: i } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || e === i)
+      return;
+    const s = this.node.animationState.setActive("exit", !e);
+    n && !e && s.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 Qi = {
+  animation: {
+    Feature: Yi
+  },
+  exit: {
+    Feature: Ji
+  }
+};
+function Pt(t) {
+  return {
+    point: {
+      x: t.pageX,
+      y: t.pageY
+    }
+  };
+}
+function We(t, e, n) {
+  const { props: i } = t;
+  t.animationState && i.whileHover && t.animationState.setActive("whileHover", n === "Start");
+  const s = "onHover" + n, r = i[s];
+  r && H.postRender(() => r(e, Pt(e)));
+}
+class es extends q {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = ki(e, (n, i) => (We(this.node, i, "Start"), (s) => We(this.node, s, "End"))));
+  }
+  unmount() {
+  }
+}
+class ts extends q {
+  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 = re(_e(this.node.current, "focus", () => this.onFocus()), _e(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+function Ue(t, e, n) {
+  const { props: i } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled)
+    return;
+  t.animationState && i.whileTap && t.animationState.setActive("whileTap", n === "Start");
+  const s = "onTap" + (n === "End" ? "" : n), r = i[s];
+  r && H.postRender(() => r(e, Pt(e)));
+}
+class ns extends q {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Ki(e, (n, i) => (Ue(this.node, i, "Start"), (s, { success: r }) => Ue(this.node, s, r ? "End" : "Cancel")), { useGlobalTarget: this.node.props.globalTapTarget }));
+  }
+  unmount() {
+  }
+}
+const be = /* @__PURE__ */ new WeakMap(), fe = /* @__PURE__ */ new WeakMap(), is = (t) => {
+  const e = be.get(t.target);
+  e && e(t);
+}, ss = (t) => {
+  t.forEach(is);
+};
+function rs({ root: t, ...e }) {
+  const n = t || document;
+  fe.has(n) || fe.set(n, {});
+  const i = fe.get(n), s = JSON.stringify(e);
+  return i[s] || (i[s] = new IntersectionObserver(ss, { root: t, ...e })), i[s];
+}
+function os(t, e, n) {
+  const i = rs(e);
+  return be.set(t, n), i.observe(t), () => {
+    be.delete(t), i.unobserve(t);
+  };
+}
+const as = {
+  some: 0,
+  all: 1
+};
+class cs extends q {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: e = {} } = this.node.getProps(), { root: n, margin: i, amount: s = "some", once: r } = e, a = {
+      root: n ? n.current : void 0,
+      rootMargin: i,
+      threshold: typeof s == "number" ? s : as[s]
+    }, o = (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 os(this.node.current, a, o);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: e, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(ls(e, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function ls({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (n) => t[n] !== e[n];
+}
+const us = {
+  inView: {
+    Feature: cs
+  },
+  tap: {
+    Feature: ns
+  },
+  focus: {
+    Feature: ts
+  },
+  hover: {
+    Feature: es
+  }
+}, fs = {
+  renderer: Xi,
+  ...Qi,
+  ...us
+};
+var ps = fs;
+export {
+  ps as default
+};