@mobielnl/elements 0.11.0 → 0.11.1

package/dist/index-BJ0cbW6P.js

@@ -0,0 +1,1763 @@
+"use client";
+import { n as j, i as N, m as Z, r as ze, h as Lt, a as qe, w as Q, b as pe, c as Ce, d as Xe, e as oe, f as Pe, t as O, g as Nt, j as G, v as Gt, k as $, M as H, K as Ye, l as $t, o as Ht, p as ge, q as Wt, s as _t, u as jt, x as Je, y as Ut, z as zt, A as qt, B as ke, C as Fe, D as z, E as Oe, F as Xt, V as Yt, G as Jt, H as Zt, I as Qt, J as en, L as tn, N as Ze, O as nn, P as sn, Q as rn, R as an, S as on, T as Qe, U as et, W as tt, X as nt, Y as ln } from "./index-BZIEZ3f4.js";
+import { Fragment as un } from "react";
+var Bt = typeof globalThis < "u" && globalThis.process ? globalThis.process : { env: { NODE_ENV: "production" } };
+// @__NO_SIDE_EFFECTS__
+function ye(t) {
+  let e;
+  return () => (e === void 0 && (e = t()), e);
+}
+const cn = (t, e) => (n) => e(t(n)), ee = (...t) => t.reduce(cn), it = /* @__NO_SIDE_EFFECTS__ */ (t, e, n) => {
+  const i = e - t;
+  return i === 0 ? 1 : (n - t) / i;
+}, F = /* @__NO_SIDE_EFFECTS__ */ (t) => t * 1e3, k = /* @__NO_SIDE_EFFECTS__ */ (t) => t / 1e3, st = (t, e, n) => (((1 - 3 * n + 3 * e) * t + (3 * n - 6 * e)) * t + 3 * e) * t, fn = 1e-7, hn = 12;
+function dn(t, e, n, i, s) {
+  let r, o, a = 0;
+  do
+    o = e + (n - e) / 2, r = st(o, i, s) - t, r > 0 ? n = o : e = o;
+  while (Math.abs(r) > fn && ++a < hn);
+  return o;
+}
+function U(t, e, n, i) {
+  if (t === e && n === i)
+    return j;
+  const s = (r) => dn(r, 0, 1, t, n);
+  return (r) => r === 0 || r === 1 ? r : st(s(r), e, i);
+}
+const rt = (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, at = (t) => (e) => 1 - t(1 - e), ot = /* @__PURE__ */ U(0.33, 1.53, 0.69, 0.99), Te = /* @__PURE__ */ at(ot), lt = /* @__PURE__ */ rt(Te), ut = (t) => (t *= 2) < 1 ? 0.5 * Te(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), be = (t) => 1 - Math.sin(Math.acos(t)), mn = at(be), ct = rt(be), pn = /* @__PURE__ */ U(0.42, 0, 1, 1), gn = /* @__PURE__ */ U(0, 0, 0.58, 1), ft = /* @__PURE__ */ U(0.42, 0, 0.58, 1), yn = (t) => Array.isArray(t) && typeof t[0] != "number", ht = (t) => Array.isArray(t) && typeof t[0] == "number", Ie = {
+  linear: j,
+  easeIn: pn,
+  easeInOut: ft,
+  easeOut: gn,
+  circIn: be,
+  circInOut: ct,
+  circOut: mn,
+  backIn: Te,
+  backInOut: lt,
+  backOut: ot,
+  anticipate: ut
+}, Tn = (t) => typeof t == "string", Ke = (t) => {
+  if (ht(t)) {
+    N(t.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+    const [e, n, i, s] = t;
+    return U(e, n, i, s);
+  } else if (Tn(t))
+    return N(Ie[t] !== void 0, `Invalid easing type '${t}'`, "invalid-easing-type"), Ie[t];
+  return t;
+};
+function te(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, o = 0;
+  if (!e)
+    s = r = o = n;
+  else {
+    const a = n < 0.5 ? n * (1 + e) : n + e - n * e, c = 2 * n - a;
+    s = te(c, a, t + 1 / 3), r = te(c, a, t), o = te(c, a, t - 1 / 3);
+  }
+  return {
+    red: Math.round(s * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(o * 255),
+    alpha: i
+  };
+}
+function X(t, e) {
+  return (n) => n > 0 ? e : t;
+}
+const ne = (t, e, n) => {
+  const i = t * t, s = n * (e * e - i) + i;
+  return s < 0 ? 0 : Math.sqrt(s);
+}, vn = [Lt, ze, qe], An = (t) => vn.find((e) => e.test(t));
+function Re(t) {
+  const e = An(t);
+  if (Q(!!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 === qe && (n = bn(n)), n;
+}
+const Ee = (t, e) => {
+  const n = Re(t), i = Re(e);
+  if (!n || !i)
+    return X(t, e);
+  const s = { ...n };
+  return (r) => (s.red = ne(n.red, i.red, r), s.green = ne(n.green, i.green, r), s.blue = ne(n.blue, i.blue, r), s.alpha = Z(n.alpha, i.alpha, r), ze.transform(s));
+}, le = /* @__PURE__ */ new Set(["none", "hidden"]);
+function xn(t, e) {
+  return le.has(t) ? (n) => n <= 0 ? t : e : (n) => n >= 1 ? e : t;
+}
+function Sn(t, e) {
+  return (n) => Z(t, e, n);
+}
+function ve(t) {
+  return typeof t == "number" ? Sn : typeof t == "string" ? pe(t) ? X : Ce.test(t) ? Ee : Mn : Array.isArray(t) ? dt : typeof t == "object" ? Ce.test(t) ? Ee : wn : X;
+}
+function dt(t, e) {
+  const n = [...t], i = n.length, s = t.map((r, o) => ve(r)(r, e[o]));
+  return (r) => {
+    for (let o = 0; o < i; o++)
+      n[o] = s[o](r);
+    return n;
+  };
+}
+function wn(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], o = t.indexes[r][i[r]], a = t.values[o] ?? 0;
+    n[s] = a, i[r]++;
+  }
+  return n;
+}
+const Mn = (t, e) => {
+  const n = Xe.createTransformer(e), i = oe(t), s = oe(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 ? le.has(t) && !s.values.length || le.has(e) && !i.values.length ? xn(t, e) : ee(dt(Vn(i, s), s.values), n) : (Q(!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"), X(t, e));
+};
+function mt(t, e, n) {
+  return typeof t == "number" && typeof e == "number" && typeof n == "number" ? Z(t, e, n) : ve(t)(t, e);
+}
+const Dn = (t) => {
+  const e = ({ timestamp: n }) => t(n);
+  return {
+    start: (n = !0) => G.update(e, n),
+    stop: () => Nt(e),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => Pe.isProcessing ? Pe.timestamp : O.now()
+  };
+}, pt = (t, e, n = 10) => {
+  let i = "";
+  const s = Math.max(Math.round(e / n), 2);
+  for (let r = 0; r < s; r++)
+    i += Math.round(t(r / (s - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${i.substring(0, i.length - 2)})`;
+}, Y = 2e4;
+function Ae(t) {
+  let e = 0;
+  const n = 50;
+  let i = t.next(e);
+  for (; !i.done && e < Y; )
+    e += n, i = t.next(e);
+  return e >= Y ? 1 / 0 : e;
+}
+function Cn(t, e = 100, n) {
+  const i = n({ ...t, keyframes: [0, e] }), s = Math.min(Ae(i), Y);
+  return {
+    type: "keyframes",
+    ease: (r) => i.next(s * r).value / e,
+    duration: /* @__PURE__ */ k(s)
+  };
+}
+const Pn = 5;
+function gt(t, e, n) {
+  const i = Math.max(e - Pn, 0);
+  return Gt(n - t(i), e - i);
+}
+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
+}, ie = 1e-3;
+function kn({ duration: t = S.duration, bounce: e = S.bounce, velocity: n = S.velocity, mass: i = S.mass }) {
+  let s, r;
+  Q(t <= /* @__PURE__ */ F(S.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let o = 1 - e;
+  o = $(S.minDamping, S.maxDamping, o), t = $(S.minDuration, S.maxDuration, /* @__PURE__ */ k(t)), o < 1 ? (s = (l) => {
+    const u = l * o, f = u * t, h = u - n, p = ue(l, o), v = Math.exp(-f);
+    return ie - h / p * v;
+  }, r = (l) => {
+    const f = l * o * t, h = f * n + n, p = Math.pow(o, 2) * Math.pow(l, 2) * t, v = Math.exp(-f), y = ue(Math.pow(l, 2), o);
+    return (-s(l) + ie > 0 ? -1 : 1) * ((h - p) * v) / y;
+  }) : (s = (l) => {
+    const u = Math.exp(-l * t), f = (l - n) * t + 1;
+    return -ie + u * f;
+  }, r = (l) => {
+    const u = Math.exp(-l * t), f = (n - l) * (t * t);
+    return u * f;
+  });
+  const a = 5 / t, c = On(s, r, a);
+  if (t = /* @__PURE__ */ F(t), isNaN(c))
+    return {
+      stiffness: S.stiffness,
+      damping: S.damping,
+      duration: t
+    };
+  {
+    const l = Math.pow(c, 2) * i;
+    return {
+      stiffness: l,
+      damping: o * 2 * Math.sqrt(i * l),
+      duration: t
+    };
+  }
+}
+const Fn = 12;
+function On(t, e, n) {
+  let i = n;
+  for (let s = 1; s < Fn; s++)
+    i = i - t(i) / e(i);
+  return i;
+}
+function ue(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const In = ["duration", "bounce"], Kn = ["stiffness", "damping", "mass"];
+function Be(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 (!Be(t, Kn) && Be(t, In))
+    if (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 = kn(t);
+      e = {
+        ...e,
+        ...n,
+        mass: S.mass
+      }, e.isResolvedFromDuration = !0;
+    }
+  return e;
+}
+function J(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], o = n.keyframes[n.keyframes.length - 1], a = { done: !1, value: r }, { stiffness: c, damping: l, mass: u, duration: f, velocity: h, isResolvedFromDuration: p } = Rn({
+    ...n,
+    velocity: -/* @__PURE__ */ k(n.velocity || 0)
+  }), v = h || 0, y = l / (2 * Math.sqrt(c * u)), T = o - r, d = /* @__PURE__ */ k(Math.sqrt(c / u)), A = Math.abs(T) < 5;
+  i || (i = A ? S.restSpeed.granular : S.restSpeed.default), s || (s = A ? S.restDelta.granular : S.restDelta.default);
+  let b;
+  if (y < 1) {
+    const m = ue(d, y);
+    b = (x) => {
+      const w = Math.exp(-y * d * x);
+      return o - w * ((v + y * d * T) / m * Math.sin(m * x) + T * Math.cos(m * x));
+    };
+  } else if (y === 1)
+    b = (m) => o - Math.exp(-d * m) * (T + (v + d * T) * m);
+  else {
+    const m = d * Math.sqrt(y * y - 1);
+    b = (x) => {
+      const w = Math.exp(-y * d * x), g = Math.min(m * x, 300);
+      return o - w * ((v + y * d * T) * Math.sinh(g) + m * T * Math.cosh(g)) / m;
+    };
+  }
+  const M = {
+    calculatedDuration: p && f || null,
+    next: (m) => {
+      const x = b(m);
+      if (p)
+        a.done = m >= f;
+      else {
+        let w = m === 0 ? v : 0;
+        y < 1 && (w = m === 0 ? /* @__PURE__ */ F(v) : gt(b, m, x));
+        const g = Math.abs(w) <= i, D = Math.abs(o - x) <= s;
+        a.done = g && D;
+      }
+      return a.value = a.done ? o : x, a;
+    },
+    toString: () => {
+      const m = Math.min(Ae(M), Y), x = pt((w) => M.next(m * w).value, m, 30);
+      return m + "ms " + x;
+    },
+    toTransition: () => {
+    }
+  };
+  return M;
+}
+J.applyToOptions = (t) => {
+  const e = Cn(t, 100, J);
+  return t.ease = e.ease, t.duration = /* @__PURE__ */ F(e.duration), t.type = "keyframes", t;
+};
+function ce({ keyframes: t, velocity: e = 0, power: n = 0.8, timeConstant: i = 325, bounceDamping: s = 10, bounceStiffness: r = 500, modifyTarget: o, min: a, max: c, restDelta: l = 0.5, restSpeed: u }) {
+  const f = t[0], h = {
+    done: !1,
+    value: f
+  }, p = (g) => a !== void 0 && g < a || c !== void 0 && g > c, v = (g) => a === void 0 ? c : c === void 0 || Math.abs(a - g) < Math.abs(c - g) ? a : c;
+  let y = n * e;
+  const T = f + y, d = o === void 0 ? T : o(T);
+  d !== T && (y = d - f);
+  const A = (g) => -y * Math.exp(-g / i), b = (g) => d + A(g), M = (g) => {
+    const D = A(g), C = b(g);
+    h.done = Math.abs(D) <= l, h.value = h.done ? d : C;
+  };
+  let m, x;
+  const w = (g) => {
+    p(h.value) && (m = g, x = J({
+      keyframes: [h.value, v(h.value)],
+      velocity: gt(b, g, h.value),
+      // TODO: This should be passing * 1000
+      damping: s,
+      stiffness: r,
+      restDelta: l,
+      restSpeed: u
+    }));
+  };
+  return w(0), {
+    calculatedDuration: null,
+    next: (g) => {
+      let D = !1;
+      return !x && m === void 0 && (D = !0, M(g), w(g)), m !== void 0 && g >= m ? x.next(g - m) : (!D && M(g), h);
+    }
+  };
+}
+function En(t, e, n) {
+  const i = [], s = n || H.mix || mt, r = t.length - 1;
+  for (let o = 0; o < r; o++) {
+    let a = s(t[o], t[o + 1]);
+    if (e) {
+      const c = Array.isArray(e) ? e[o] || j : e;
+      a = ee(c, a);
+    }
+    i.push(a);
+  }
+  return i;
+}
+function Bn(t, e, { clamp: n = !0, ease: i, mixer: s } = {}) {
+  const r = t.length;
+  if (N(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 o = t[0] === t[1];
+  t[0] > t[r - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const a = En(e, i, s), c = a.length, l = (u) => {
+    if (o && u < t[0])
+      return e[0];
+    let f = 0;
+    if (c > 1)
+      for (; f < t.length - 2 && !(u < t[f + 1]); f++)
+        ;
+    const h = /* @__PURE__ */ it(t[f], t[f + 1], u);
+    return a[f](h);
+  };
+  return n ? (u) => l($(t[0], t[r - 1], u)) : l;
+}
+function Ln(t, e) {
+  const n = t[t.length - 1];
+  for (let i = 1; i <= e; i++) {
+    const s = /* @__PURE__ */ it(0, e, i);
+    t.push(Z(n, 1, s));
+  }
+}
+function Nn(t) {
+  const e = [0];
+  return Ln(e, t.length - 1), e;
+}
+function Gn(t, e) {
+  return t.map((n) => n * e);
+}
+function $n(t, e) {
+  return t.map(() => e || ft).splice(0, t.length - 1);
+}
+function B({ duration: t = 300, keyframes: e, times: n, ease: i = "easeInOut" }) {
+  const s = yn(i) ? i.map(Ke) : Ke(i), r = {
+    done: !1,
+    value: e[0]
+  }, o = Gn(
+    // 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 : Nn(e),
+    t
+  ), a = Bn(o, e, {
+    ease: Array.isArray(s) ? s : $n(e, s)
+  });
+  return {
+    calculatedDuration: t,
+    next: (c) => (r.value = a(c), r.done = c >= t, r)
+  };
+}
+const Hn = (t) => t !== null;
+function xe(t, { repeat: e, repeatType: n = "loop" }, i, s = 1) {
+  const r = t.filter(Hn), a = s < 0 || e && n !== "loop" && e % 2 === 1 ? 0 : r.length - 1;
+  return !a || i === void 0 ? r[a] : i;
+}
+const Wn = {
+  decay: ce,
+  inertia: ce,
+  tween: B,
+  keyframes: B,
+  spring: J
+};
+function yt(t) {
+  typeof t.type == "string" && (t.type = Wn[t.type]);
+}
+class Se {
+  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 _n = (t) => t / 100;
+class we extends Se {
+  constructor(e) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+      const { motionValue: n } = this.options;
+      n && n.updatedAt !== O.now() && this.tick(O.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: e } = this;
+    yt(e);
+    const { type: n = B, repeat: i = 0, repeatDelay: s = 0, repeatType: r, velocity: o = 0 } = e;
+    let { keyframes: a } = e;
+    const c = n || B;
+    Bt.env.NODE_ENV !== "production" && c !== B && N(a.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${a}`, "spring-two-frames"), c !== B && typeof a[0] != "number" && (this.mixKeyframes = ee(_n, mt(a[0], a[1])), a = [0, 100]);
+    const l = c({ ...e, keyframes: a });
+    r === "mirror" && (this.mirroredGenerator = c({
+      ...e,
+      keyframes: [...a].reverse(),
+      velocity: -o
+    })), l.calculatedDuration === null && (l.calculatedDuration = Ae(l));
+    const { calculatedDuration: u } = l;
+    this.calculatedDuration = u, this.resolvedDuration = u + 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: o, resolvedDuration: a, calculatedDuration: c } = this;
+    if (this.startTime === null)
+      return i.next(0);
+    const { delay: l = 0, keyframes: u, repeat: f, repeatType: h, repeatDelay: p, type: v, onUpdate: y, finalKeyframe: T } = 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 d = this.currentTime - l * (this.playbackSpeed >= 0 ? 1 : -1), A = this.playbackSpeed >= 0 ? d < 0 : d > s;
+    this.currentTime = Math.max(d, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
+    let b = this.currentTime, M = i;
+    if (f) {
+      const g = Math.min(this.currentTime, s) / a;
+      let D = Math.floor(g), C = g % 1;
+      !C && g >= 1 && (C = 1), C === 1 && D--, D = Math.min(D, f + 1), !!(D % 2) && (h === "reverse" ? (C = 1 - C, p && (C -= p / a)) : h === "mirror" && (M = o)), b = $(0, 1, C) * a;
+    }
+    const m = A ? { done: !1, value: u[0] } : M.next(b);
+    r && (m.value = r(m.value));
+    let { done: x } = m;
+    !A && c !== null && (x = this.playbackSpeed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
+    const w = this.holdTime === null && (this.state === "finished" || this.state === "running" && x);
+    return w && v !== ce && (m.value = xe(u, this.options, T, this.speed)), y && y(m.value), w && 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 iterationDuration() {
+    const { delay: e = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ k(e);
+  }
+  get time() {
+    return /* @__PURE__ */ k(this.currentTime);
+  }
+  set time(e) {
+    e = /* @__PURE__ */ F(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?.start(!1);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(e) {
+    this.updateTime(O.now());
+    const n = this.playbackSpeed !== e;
+    this.playbackSpeed = e, n && (this.time = /* @__PURE__ */ k(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: e = Dn, 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(O.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(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 jn = (t) => t.startsWith("--");
+function Un(t, e, n) {
+  jn(e) ? t.style.setProperty(e, n) : t.style[e] = n;
+}
+const zn = /* @__PURE__ */ ye(() => window.ScrollTimeline !== void 0), qn = {};
+function Xn(t, e) {
+  const n = /* @__PURE__ */ ye(t);
+  return () => qn[e] ?? n();
+}
+const Tt = /* @__PURE__ */ Xn(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing"), _ = ([t, e, n, i]) => `cubic-bezier(${t}, ${e}, ${n}, ${i})`, Le = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ _([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ _([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ _([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ _([0.33, 1.53, 0.69, 0.99])
+};
+function bt(t, e) {
+  if (t)
+    return typeof t == "function" ? Tt() ? pt(t, e) : "ease-out" : ht(t) ? _(t) : Array.isArray(t) ? t.map((n) => bt(n, e) || Le.easeOut) : Le[t];
+}
+function Yn(t, e, n, { delay: i = 0, duration: s = 300, repeat: r = 0, repeatType: o = "loop", ease: a = "easeOut", times: c } = {}, l = void 0) {
+  const u = {
+    [e]: n
+  };
+  c && (u.offset = c);
+  const f = bt(a, s);
+  Array.isArray(f) && (u.easing = f);
+  const h = {
+    delay: i,
+    duration: s,
+    easing: Array.isArray(f) ? "linear" : f,
+    fill: "both",
+    iterations: r + 1,
+    direction: o === "reverse" ? "alternate" : "normal"
+  };
+  return l && (h.pseudoElement = l), t.animate(u, h);
+}
+function vt(t) {
+  return typeof t == "function" && "applyToOptions" in t;
+}
+function Jn({ type: t, ...e }) {
+  return vt(t) && Tt() ? t.applyToOptions(e) : (e.duration ?? (e.duration = 300), e.ease ?? (e.ease = "easeOut"), e);
+}
+class Zn extends Se {
+  constructor(e) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !e)
+      return;
+    const { element: n, name: i, keyframes: s, pseudoElement: r, allowFlatten: o = !1, finalKeyframe: a, onComplete: c } = e;
+    this.isPseudoElement = !!r, this.allowFlatten = o, this.options = e, N(typeof e.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
+    const l = Jn(e);
+    this.animation = Yn(n, i, s, l, r), l.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !r) {
+        const u = xe(s, this.options, a, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(u) : Un(n, i, u), this.animation.cancel();
+      }
+      c?.(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.finish?.();
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: 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() {
+    this.isPseudoElement || this.animation.commitStyles?.();
+  }
+  get duration() {
+    const e = this.animation.effect?.getComputedTiming?.().duration || 0;
+    return /* @__PURE__ */ k(Number(e));
+  }
+  get iterationDuration() {
+    const { delay: e = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ k(e);
+  }
+  get time() {
+    return /* @__PURE__ */ k(Number(this.animation.currentTime) || 0);
+  }
+  set time(e) {
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ F(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 this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(e) {
+    this.manualStartTime = this.animation.startTime = e;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: e, observe: n }) {
+    return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, e && zn() ? (this.animation.timeline = e, j) : n(this);
+  }
+}
+const At = {
+  anticipate: ut,
+  backInOut: lt,
+  circInOut: ct
+};
+function Qn(t) {
+  return t in At;
+}
+function ei(t) {
+  typeof t.ease == "string" && Qn(t.ease) && (t.ease = At[t.ease]);
+}
+const se = 10;
+class ti extends Zn {
+  constructor(e) {
+    ei(e), yt(e), super(e), e.startTime !== void 0 && (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, ...o } = this.options;
+    if (!n)
+      return;
+    if (e !== void 0) {
+      n.set(e);
+      return;
+    }
+    const a = new we({
+      ...o,
+      autoplay: !1
+    }), c = Math.max(se, O.now() - this.startTime), l = $(0, se, c - se);
+    n.setWithVelocity(a.sample(Math.max(0, c - l)).value, a.sample(c).value, l), a.stop();
+  }
+}
+const Ne = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(Xe.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url("));
+function ni(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 ii(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], o = Ne(s, e), a = Ne(r, e);
+  return Q(o === a, `You are trying to animate ${e} from "${s}" to "${r}". "${o ? r : s}" is not an animatable value.`, "value-not-animatable"), !o || !a ? !1 : ni(t) || (n === "spring" || vt(n)) && i;
+}
+function fe(t) {
+  t.duration = 0, t.type = "keyframes";
+}
+const si = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Could be re-enabled now we have support for linear() easing
+  // "background-color"
+]), ri = /* @__PURE__ */ ye(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function ai(t) {
+  const { motionValue: e, name: n, repeatDelay: i, repeatType: s, damping: r, type: o } = t;
+  if (!(e?.owner?.current instanceof HTMLElement))
+    return !1;
+  const { onUpdate: c, transformTemplate: l } = e.owner.getProps();
+  return ri() && n && si.has(n) && (n !== "transform" || !l) && /**
+   * If we're outputting values to onUpdate then we can't use WAAPI as there's
+   * no way to read the value from WAAPI every frame.
+   */
+  !c && !i && s !== "mirror" && r !== 0 && o !== "inertia";
+}
+const oi = 40;
+class li extends Se {
+  constructor({ autoplay: e = !0, delay: n = 0, type: i = "keyframes", repeat: s = 0, repeatDelay: r = 0, repeatType: o = "loop", keyframes: a, name: c, motionValue: l, element: u, ...f }) {
+    super(), this.stop = () => {
+      this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+    }, this.createdAt = O.now();
+    const h = {
+      autoplay: e,
+      delay: n,
+      type: i,
+      repeat: s,
+      repeatDelay: r,
+      repeatType: o,
+      name: c,
+      motionValue: l,
+      element: u,
+      ...f
+    }, p = u?.KeyframeResolver || Ye;
+    this.keyframeResolver = new p(a, (v, y, T) => this.onKeyframesResolved(v, y, h, !T), c, l, u), this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(e, n, i, s) {
+    this.keyframeResolver = void 0;
+    const { name: r, type: o, velocity: a, delay: c, isHandoff: l, onUpdate: u } = i;
+    this.resolvedAt = O.now(), ii(e, r, o, a) || ((H.instantAnimations || !c) && u?.(xe(e, i, n)), e[0] = e[e.length - 1], fe(i), i.repeat = 0);
+    const h = {
+      startTime: s ? this.resolvedAt ? this.resolvedAt - this.createdAt > oi ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: n,
+      ...i,
+      keyframes: e
+    }, p = !l && ai(h), v = h.motionValue?.owner?.current, y = p ? new ti({
+      ...h,
+      element: v
+    }) : new we(h);
+    y.finished.then(() => {
+      this.notifyFinished();
+    }).catch(j), this.pendingTimeline && (this.stopTimeline = y.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = y;
+  }
+  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 xt(t, e, n, i = 0, s = 1) {
+  const r = Array.from(t).sort((l, u) => l.sortNodePosition(u)).indexOf(e), o = t.size, a = (o - 1) * i;
+  return typeof n == "function" ? n(r, o) : s === 1 ? r * i : a - r * i;
+}
+const 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 ci(t) {
+  const e = ui.exec(t);
+  if (!e)
+    return [,];
+  const [, n, i, s] = e;
+  return [`--${n ?? i}`, s];
+}
+const fi = 4;
+function St(t, e, n = 1) {
+  N(n <= fi, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [i, s] = ci(t);
+  if (!i)
+    return;
+  const r = window.getComputedStyle(e).getPropertyValue(i);
+  if (r) {
+    const o = r.trim();
+    return Ht(o) ? parseFloat(o) : o;
+  }
+  return pe(s) ? St(s, e, n + 1) : s;
+}
+const hi = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, di = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), mi = {
+  type: "keyframes",
+  duration: 0.8
+}, pi = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, gi = (t, { keyframes: e }) => e.length > 2 ? mi : ge.has(t) ? t.startsWith("scale") ? di(e[1]) : hi : pi, yi = (t) => t !== null;
+function Ti(t, { repeat: e, repeatType: n = "loop" }, i) {
+  const s = t.filter(yi), r = e && n !== "loop" && e % 2 === 1 ? 0 : s.length - 1;
+  return s[r];
+}
+function wt(t, e) {
+  return t?.[e] ?? t?.default ?? t;
+}
+function bi({ when: t, delay: e, delayChildren: n, staggerChildren: i, staggerDirection: s, repeat: r, repeatType: o, repeatDelay: a, from: c, elapsed: l, ...u }) {
+  return !!Object.keys(u).length;
+}
+const vi = (t, e, n, i = {}, s, r) => (o) => {
+  const a = wt(i, t) || {}, c = a.delay || i.delay || 0;
+  let { elapsed: l = 0 } = i;
+  l = l - /* @__PURE__ */ F(c);
+  const u = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...a,
+    delay: -l,
+    onUpdate: (h) => {
+      e.set(h), a.onUpdate && a.onUpdate(h);
+    },
+    onComplete: () => {
+      o(), a.onComplete && a.onComplete();
+    },
+    name: t,
+    motionValue: e,
+    element: r ? void 0 : s
+  };
+  bi(a) || Object.assign(u, gi(t, u)), u.duration && (u.duration = /* @__PURE__ */ F(u.duration)), u.repeatDelay && (u.repeatDelay = /* @__PURE__ */ F(u.repeatDelay)), u.from !== void 0 && (u.keyframes[0] = u.from);
+  let f = !1;
+  if ((u.type === !1 || u.duration === 0 && !u.repeatDelay) && (fe(u), u.delay === 0 && (f = !0)), (H.instantAnimations || H.skipAnimations) && (f = !0, fe(u), u.delay = 0), u.allowFlatten = !a.type && !a.ease, f && !r && e.get() !== void 0) {
+    const h = Ti(u.keyframes, a);
+    if (h !== void 0) {
+      G.update(() => {
+        u.onUpdate(h), u.onComplete();
+      });
+      return;
+    }
+  }
+  return a.isSync ? new we(u) : new li(u);
+};
+function L(t, e, n) {
+  const i = t.getProps();
+  return Wt(i, e, n !== void 0 ? n : i.custom, t);
+}
+const Vt = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ..._t
+]), he = (t) => Array.isArray(t);
+function Ai(t, e, n) {
+  t.hasValue(e) ? t.getValue(e).set(n) : t.addValue(e, jt(n));
+}
+function xi(t) {
+  return he(t) ? t[t.length - 1] || 0 : t;
+}
+function Si(t, e) {
+  const n = L(t, e);
+  let { transitionEnd: i = {}, transition: s = {}, ...r } = n || {};
+  r = { ...r, ...i };
+  for (const o in r) {
+    const a = xi(r[o]);
+    Ai(t, o, a);
+  }
+}
+function wi(t) {
+  return !!(Je(t) && t.add);
+}
+function Vi(t, e) {
+  const n = t.getValue("willChange");
+  if (wi(n))
+    return n.add(e);
+  if (!n && H.WillChange) {
+    const i = new H.WillChange("auto");
+    t.addValue("willChange", i), i.add(e);
+  }
+}
+function Mi(t) {
+  return t.props[Ut];
+}
+function Di({ protectedKeys: t, needsAnimating: e }, n) {
+  const i = t.hasOwnProperty(n) && e[n] !== !0;
+  return e[n] = !1, i;
+}
+function Mt(t, e, { delay: n = 0, transitionOverride: i, type: s } = {}) {
+  let { transition: r = t.getDefaultTransition(), transitionEnd: o, ...a } = e;
+  const c = r?.reduceMotion;
+  i && (r = i);
+  const l = [], u = s && t.animationState && t.animationState.getState()[s];
+  for (const f in a) {
+    const h = t.getValue(f, t.latestValues[f] ?? null), p = a[f];
+    if (p === void 0 || u && Di(u, f))
+      continue;
+    const v = {
+      delay: n,
+      ...wt(r || {}, f)
+    }, y = h.get();
+    if (y !== void 0 && !h.isAnimating && !Array.isArray(p) && p === y && !v.velocity)
+      continue;
+    let T = !1;
+    if (window.MotionHandoffAnimation) {
+      const b = Mi(t);
+      if (b) {
+        const M = window.MotionHandoffAnimation(b, f, G);
+        M !== null && (v.startTime = M, T = !0);
+      }
+    }
+    Vi(t, f);
+    const d = c ?? t.shouldReduceMotion;
+    h.start(vi(f, h, p, d && Vt.has(f) ? { type: !1 } : v, t, T));
+    const A = h.animation;
+    A && l.push(A);
+  }
+  return o && Promise.all(l).then(() => {
+    G.update(() => {
+      o && Si(t, o);
+    });
+  }), l;
+}
+function de(t, e, n = {}) {
+  const i = L(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(Mt(t, i, n)) : () => Promise.resolve(), o = t.variantChildren && t.variantChildren.size ? (c = 0) => {
+    const { delayChildren: l = 0, staggerChildren: u, staggerDirection: f } = s;
+    return Ci(t, e, c, l, u, f, n);
+  } : () => Promise.resolve(), { when: a } = s;
+  if (a) {
+    const [c, l] = a === "beforeChildren" ? [r, o] : [o, r];
+    return c().then(() => l());
+  } else
+    return Promise.all([r(), o(n.delay)]);
+}
+function Ci(t, e, n = 0, i = 0, s = 0, r = 1, o) {
+  const a = [];
+  for (const c of t.variantChildren)
+    c.notify("AnimationStart", e), a.push(de(c, e, {
+      ...o,
+      delay: n + (typeof i == "function" ? 0 : i) + xt(t.variantChildren, c, i, s, r)
+    }).then(() => c.notify("AnimationComplete", e)));
+  return Promise.all(a);
+}
+function Pi(t, e, n = {}) {
+  t.notify("AnimationStart", e);
+  let i;
+  if (Array.isArray(e)) {
+    const s = e.map((r) => de(t, r, n));
+    i = Promise.all(s);
+  } else if (typeof e == "string")
+    i = de(t, e, n);
+  else {
+    const s = typeof e == "function" ? L(t, e, n.custom) : e;
+    i = Promise.all(Mt(t, s, n));
+  }
+  return i.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+function ki(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || zt(t) : !0;
+}
+const Fi = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function Oi(t, e, n) {
+  let i = 0, s;
+  for (; i < t.length && !s; ) {
+    const r = t[i];
+    typeof r == "string" && !Fi.has(r) && oe(r).values.length && (s = t[i]), i++;
+  }
+  if (s && n)
+    for (const r of e)
+      t[r] = qt(n, s);
+}
+class Ii extends Ye {
+  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 u = 0; u < e.length; u++) {
+      let f = e[u];
+      if (typeof f == "string" && (f = f.trim(), pe(f))) {
+        const h = St(f, n.current);
+        h !== void 0 && (e[u] = h), u === e.length - 1 && (this.finalKeyframe = f);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !Vt.has(i) || e.length !== 2)
+      return;
+    const [s, r] = e, o = ke(s), a = ke(r), c = Fe(s), l = Fe(r);
+    if (c !== l && z[i]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (o !== a)
+      if (Oe(o) && Oe(a))
+        for (let u = 0; u < e.length; u++) {
+          const f = e[u];
+          typeof f == "string" && (e[u] = parseFloat(f));
+        }
+      else z[i] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, i = [];
+    for (let s = 0; s < e.length; s++)
+      (e[s] === null || ki(e[s])) && i.push(s);
+    i.length && Oi(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 = z[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, o = i[r];
+    i[r] = z[n](e.measureViewportBox(), window.getComputedStyle(e.current)), o !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = o), this.removedTransforms?.length && this.removedTransforms.forEach(([a, c]) => {
+      e.getValue(a).set(c);
+    }), this.resolveNoneKeyframes();
+  }
+}
+function Ki(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 Ri = {
+  y: !1
+};
+function Ei() {
+  return Ri.y;
+}
+function Dt(t, e) {
+  const n = Ki(t), i = new AbortController(), s = {
+    passive: !0,
+    ...e,
+    signal: i.signal
+  };
+  return [n, s, () => i.abort()];
+}
+function Ge(t) {
+  return !(t.pointerType === "touch" || Ei());
+}
+function Bi(t, e, n = {}) {
+  const [i, s, r] = Dt(t, n), o = (a) => {
+    if (!Ge(a))
+      return;
+    const { target: c } = a, l = e(c, a);
+    if (typeof l != "function" || !c)
+      return;
+    const u = (f) => {
+      Ge(f) && (l(f), c.removeEventListener("pointerleave", u));
+    };
+    c.addEventListener("pointerleave", u, s);
+  };
+  return i.forEach((a) => {
+    a.addEventListener("pointerenter", o, s);
+  }), r;
+}
+const Ct = (t, e) => e ? t === e ? !0 : Ct(t, e.parentElement) : !1, Li = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, Ni = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function Gi(t) {
+  return Ni.has(t.tagName) || t.isContentEditable === !0;
+}
+const q = /* @__PURE__ */ new WeakSet();
+function $e(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function re(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
+}
+const $i = (t, e) => {
+  const n = t.currentTarget;
+  if (!n)
+    return;
+  const i = $e(() => {
+    if (q.has(n))
+      return;
+    re(n, "down");
+    const s = $e(() => {
+      re(n, "up");
+    }), r = () => re(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 He(t) {
+  return Li(t) && !0;
+}
+function Hi(t, e, n = {}) {
+  const [i, s, r] = Dt(t, n), o = (a) => {
+    const c = a.currentTarget;
+    if (!He(a))
+      return;
+    q.add(c);
+    const l = e(c, a), u = (p, v) => {
+      window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", h), q.has(c) && q.delete(c), He(p) && typeof l == "function" && l(p, { success: v });
+    }, f = (p) => {
+      u(p, c === window || c === document || n.useGlobalTarget || Ct(c, p.target));
+    }, h = (p) => {
+      u(p, !1);
+    };
+    window.addEventListener("pointerup", f, s), window.addEventListener("pointercancel", h, s);
+  };
+  return i.forEach((a) => {
+    (n.useGlobalTarget ? window : a).addEventListener("pointerdown", o, s), Xt(a) && (a.addEventListener("focus", (l) => $i(l, s)), !Gi(a) && !a.hasAttribute("tabindex") && (a.tabIndex = 0));
+  }), r;
+}
+class Pt extends Yt {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = Ii;
+  }
+  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;
+    Je(e) && (this.childSubscription = e.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+class W {
+  constructor(e) {
+    this.isMounted = !1, this.node = e;
+  }
+  update() {
+  }
+}
+function Wi({ top: t, left: e, right: n, bottom: i }) {
+  return {
+    x: { min: e, max: n },
+    y: { min: t, max: i }
+  };
+}
+function _i(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 ji(t, e) {
+  return Wi(_i(t.getBoundingClientRect(), e));
+}
+function kt(t, { style: e, vars: n }, i, s) {
+  const r = t.style;
+  let o;
+  for (o in e)
+    r[o] = e[o];
+  s?.applyProjectionStyles(r, i);
+  for (o in n)
+    r.setProperty(o, n[o]);
+}
+function Ui(t) {
+  return window.getComputedStyle(t);
+}
+class zi extends Pt {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = kt;
+  }
+  readValueFromInstance(e, n) {
+    if (ge.has(n))
+      return this.projection?.isProjecting ? Jt(n) : Zt(e, n);
+    {
+      const i = Ui(e), s = (Qt(n) ? i.getPropertyValue(n) : i[n]) || 0;
+      return typeof s == "string" ? s.trim() : s;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: n }) {
+    return ji(e, n);
+  }
+  build(e, n, i) {
+    en(e, n, i.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, n, i) {
+    return tn(e, n, i);
+  }
+}
+const Ft = /* @__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 qi(t, e, n, i) {
+  kt(t, e, void 0, i);
+  for (const s in e.attrs)
+    t.setAttribute(Ft.has(s) ? s : Ze(s), e.attrs[s]);
+}
+class Xi extends Pt {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = nn;
+  }
+  getBaseTargetFromProps(e, n) {
+    return e[n];
+  }
+  readValueFromInstance(e, n) {
+    if (ge.has(n)) {
+      const i = sn(n);
+      return i && i.default || 0;
+    }
+    return n = Ft.has(n) ? n : Ze(n), e.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(e, n, i) {
+    return rn(e, n, i);
+  }
+  build(e, n, i) {
+    an(e, n, this.isSVGTag, i.transformTemplate, i.style);
+  }
+  renderInstance(e, n, i, s) {
+    qi(e, n, i, s);
+  }
+  mount(e) {
+    this.isSVGTag = on(e.tagName), super.mount(e);
+  }
+}
+const Yi = et.length;
+function Ot(t) {
+  if (!t)
+    return;
+  if (!t.isControllingVariants) {
+    const n = t.parent ? Ot(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (n.initial = t.props.initial), n;
+  }
+  const e = {};
+  for (let n = 0; n < Yi; n++) {
+    const i = et[n], s = t.props[i];
+    (Qe(s) || s === !1) && (e[i] = s);
+  }
+  return e;
+}
+function It(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 Ji = [...nt].reverse(), Zi = nt.length;
+function Qi(t) {
+  return (e) => Promise.all(e.map(({ animation: n, options: i }) => Pi(t, n, i)));
+}
+function es(t) {
+  let e = Qi(t), n = We(), i = !0;
+  const s = (c) => (l, u) => {
+    const f = L(t, u, c === "exit" ? t.presenceContext?.custom : void 0);
+    if (f) {
+      const { transition: h, transitionEnd: p, ...v } = f;
+      l = { ...l, ...v, ...p };
+    }
+    return l;
+  };
+  function r(c) {
+    e = c(t);
+  }
+  function o(c) {
+    const { props: l } = t, u = Ot(t.parent) || {}, f = [], h = /* @__PURE__ */ new Set();
+    let p = {}, v = 1 / 0;
+    for (let T = 0; T < Zi; T++) {
+      const d = Ji[T], A = n[d], b = l[d] !== void 0 ? l[d] : u[d], M = Qe(b), m = d === c ? A.isActive : null;
+      m === !1 && (v = T);
+      let x = b === u[d] && b !== l[d] && M;
+      if (x && i && t.manuallyAnimateOnMount && (x = !1), A.protectedKeys = { ...p }, // If it isn't active and hasn't *just* been set as inactive
+      !A.isActive && m === null || // If we didn't and don't have any defined prop for this animation type
+      !b && !A.prevProp || // Or if the prop doesn't define an animation
+      tt(b) || typeof b == "boolean")
+        continue;
+      const w = ts(A.prevProp, b);
+      let g = w || // If we're making this variant active, we want to always make it active
+      d === c && A.isActive && !x && M || // If we removed a higher-priority variant (i is in reverse order)
+      T > v && M, D = !1;
+      const C = Array.isArray(b) ? b : [b];
+      let R = C.reduce(s(d), {});
+      m === !1 && (R = {});
+      const { prevResolvedValues: Ve = {} } = A, Rt = {
+        ...Ve,
+        ...R
+      }, Me = (V) => {
+        g = !0, h.has(V) && (D = !0, h.delete(V)), A.needsAnimating[V] = !0;
+        const P = t.getValue(V);
+        P && (P.liveStyle = !1);
+      };
+      for (const V in Rt) {
+        const P = R[V], I = Ve[V];
+        if (p.hasOwnProperty(V))
+          continue;
+        let E = !1;
+        he(P) && he(I) ? E = !It(P, I) : E = P !== I, E ? P != null ? Me(V) : h.add(V) : P !== void 0 && h.has(V) ? Me(V) : A.protectedKeys[V] = !0;
+      }
+      A.prevProp = b, A.prevResolvedValues = R, A.isActive && (p = { ...p, ...R }), i && t.blockInitialAnimation && (g = !1);
+      const De = x && w;
+      g && (!De || D) && f.push(...C.map((V) => {
+        const P = { type: d };
+        if (typeof V == "string" && i && !De && t.manuallyAnimateOnMount && t.parent) {
+          const { parent: I } = t, E = L(I, V);
+          if (I.enteringChildren && E) {
+            const { delayChildren: Et } = E.transition || {};
+            P.delay = xt(I.enteringChildren, t, Et);
+          }
+        }
+        return {
+          animation: V,
+          options: P
+        };
+      }));
+    }
+    if (h.size) {
+      const T = {};
+      if (typeof l.initial != "boolean") {
+        const d = L(t, Array.isArray(l.initial) ? l.initial[0] : l.initial);
+        d && d.transition && (T.transition = d.transition);
+      }
+      h.forEach((d) => {
+        const A = t.getBaseTarget(d), b = t.getValue(d);
+        b && (b.liveStyle = !0), T[d] = A ?? null;
+      }), f.push({ animation: T });
+    }
+    let y = !!f.length;
+    return i && (l.initial === !1 || l.initial === l.animate) && !t.manuallyAnimateOnMount && (y = !1), i = !1, y ? e(f) : Promise.resolve();
+  }
+  function a(c, l) {
+    if (n[c].isActive === l)
+      return Promise.resolve();
+    t.variantChildren?.forEach((f) => f.animationState?.setActive(c, l)), n[c].isActive = l;
+    const u = o(c);
+    for (const f in n)
+      n[f].protectedKeys = {};
+    return u;
+  }
+  return {
+    animateChanges: o,
+    setActive: a,
+    setAnimateFunction: r,
+    getState: () => n,
+    reset: () => {
+      n = We();
+    }
+  };
+}
+function ts(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !It(e, t) : !1;
+}
+function K(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function We() {
+  return {
+    animate: K(!0),
+    whileInView: K(),
+    whileHover: K(),
+    whileTap: K(),
+    whileDrag: K(),
+    whileFocus: K(),
+    exit: K()
+  };
+}
+function _e(t, e, n, i = { passive: !0 }) {
+  return t.addEventListener(e, n, i), () => t.removeEventListener(e, n);
+}
+const ns = (t, e) => e.isSVG ?? ln(t) ? new Xi(e) : new zi(e, {
+  allowProjection: t !== un
+});
+class is extends W {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(e) {
+    super(e), e.animationState || (e.animationState = es(e));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: e } = this.node.getProps();
+    tt(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 ss = 0;
+class rs extends W {
+  constructor() {
+    super(...arguments), this.id = ss++;
+  }
+  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 as = {
+  animation: {
+    Feature: is
+  },
+  exit: {
+    Feature: rs
+  }
+};
+function Kt(t) {
+  return {
+    point: {
+      x: t.pageX,
+      y: t.pageY
+    }
+  };
+}
+function je(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 && G.postRender(() => r(e, Kt(e)));
+}
+class os extends W {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Bi(e, (n, i) => (je(this.node, i, "Start"), (s) => je(this.node, s, "End"))));
+  }
+  unmount() {
+  }
+}
+class ls extends W {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let e = !1;
+    try {
+      e = this.node.current.matches(":focus-visible");
+    } catch {
+      e = !0;
+    }
+    !e || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = ee(_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 && G.postRender(() => r(e, Kt(e)));
+}
+class us extends W {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = Hi(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 me = /* @__PURE__ */ new WeakMap(), ae = /* @__PURE__ */ new WeakMap(), cs = (t) => {
+  const e = me.get(t.target);
+  e && e(t);
+}, fs = (t) => {
+  t.forEach(cs);
+};
+function hs({ root: t, ...e }) {
+  const n = t || document;
+  ae.has(n) || ae.set(n, {});
+  const i = ae.get(n), s = JSON.stringify(e);
+  return i[s] || (i[s] = new IntersectionObserver(fs, { root: t, ...e })), i[s];
+}
+function ds(t, e, n) {
+  const i = hs(e);
+  return me.set(t, n), i.observe(t), () => {
+    me.delete(t), i.unobserve(t);
+  };
+}
+const ms = {
+  some: 0,
+  all: 1
+};
+class ps extends W {
+  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, o = {
+      root: n ? n.current : void 0,
+      rootMargin: i,
+      threshold: typeof s == "number" ? s : ms[s]
+    }, a = (c) => {
+      const { isIntersecting: l } = c;
+      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: u, onViewportLeave: f } = this.node.getProps(), h = l ? u : f;
+      h && h(c);
+    };
+    return ds(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(gs(e, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function gs({ viewport: t = {} }, { viewport: e = {} } = {}) {
+  return (n) => t[n] !== e[n];
+}
+const ys = {
+  inView: {
+    Feature: ps
+  },
+  tap: {
+    Feature: us
+  },
+  focus: {
+    Feature: ls
+  },
+  hover: {
+    Feature: os
+  }
+}, Ts = {
+  renderer: ns,
+  ...as,
+  ...ys
+};
+var xs = Ts;
+export {
+  xs as default
+};