motion-v 0.1.0

package/dist/index.js

@@ -0,0 +1,3722 @@
+import { unref as Cn, ref as Fn, computed as zs, inject as js, provide as Us, Fragment as Hs, defineComponent as Pt, Comment as qs, mergeProps as ee, cloneVNode as Ys, h as Rt, mergeDefaults as Xs, onMounted as Zs, onUnmounted as Qs, onUpdated as Js, openBlock as On, createBlock as Dn, withCtx as Rn, renderSlot as In, toRefs as ti, resolveDynamicComponent as ei, TransitionGroup as ni, Transition as si } from "vue";
+function ii(e, t) {
+  e.indexOf(t) === -1 && e.push(t);
+}
+function Bn(e, t) {
+  const n = e.indexOf(t);
+  n > -1 && e.splice(n, 1);
+}
+class Ln {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(t) {
+    return ii(this.subscriptions, t), () => Bn(this.subscriptions, t);
+  }
+  notify(t, n, s) {
+    const i = this.subscriptions.length;
+    if (i)
+      if (i === 1)
+        this.subscriptions[0](t, n, s);
+      else
+        for (let r = 0; r < i; r++) {
+          const o = this.subscriptions[r];
+          o && o(t, n, s);
+        }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}
+function ne(e, t) {
+  return t ? e * (1e3 / t) : 0;
+}
+const Ne = /* @__PURE__ */ new Set();
+function Ct(e, t, n) {
+  e || Ne.has(t) || (console.warn(t), Ne.add(t));
+}
+const ri = {
+  skipAnimations: !1,
+  useManualTiming: !1
+}, N = (e) => e;
+function oi(e) {
+  let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), s = !1, i = !1;
+  const r = /* @__PURE__ */ new WeakSet();
+  let o = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  };
+  function a(u) {
+    r.has(u) && (l.schedule(u), e()), u(o);
+  }
+  const l = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (u, c = !1, f = !1) => {
+      const p = f && s ? t : n;
+      return c && r.add(u), p.has(u) || p.add(u), u;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (u) => {
+      n.delete(u), r.delete(u);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (u) => {
+      if (o = u, s) {
+        i = !0;
+        return;
+      }
+      s = !0, [t, n] = [n, t], n.clear(), t.forEach(a), s = !1, i && (i = !1, l.process(u));
+    }
+  };
+  return l;
+}
+const J = [
+  "read",
+  // Read
+  "resolveKeyframes",
+  // Write/Read/Write/Read
+  "update",
+  // Compute
+  "preRender",
+  // Compute
+  "render",
+  // Write
+  "postRender"
+  // Compute
+], ai = 40;
+function li(e, t) {
+  let n = !1, s = !0;
+  const i = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, r = () => n = !0, o = J.reduce((g, y) => (g[y] = oi(r), g), {}), { read: a, resolveKeyframes: l, update: u, preRender: c, render: f, postRender: h } = o, p = () => {
+    const g = performance.now();
+    n = !1, i.delta = s ? 1e3 / 60 : Math.max(Math.min(g - i.timestamp, ai), 1), i.timestamp = g, i.isProcessing = !0, a.process(i), l.process(i), u.process(i), c.process(i), f.process(i), h.process(i), i.isProcessing = !1, n && t && (s = !1, e(p));
+  }, m = () => {
+    n = !0, s = !0, i.isProcessing || e(p);
+  };
+  return { schedule: J.reduce((g, y) => {
+    const S = o[y];
+    return g[y] = (x, T = !1, A = !1) => (n || m(), S.schedule(x, T, A)), g;
+  }, {}), cancel: (g) => {
+    for (let y = 0; y < J.length; y++)
+      o[J[y]].cancel(g);
+  }, state: i, steps: o };
+}
+const { schedule: M, cancel: _, state: st, steps: yl } = li(typeof requestAnimationFrame < "u" ? requestAnimationFrame : N, !0);
+let vt;
+function ui() {
+  vt = void 0;
+}
+const B = {
+  now: () => (vt === void 0 && B.set(st.isProcessing || ri.useManualTiming ? st.timestamp : performance.now()), vt),
+  set: (e) => {
+    vt = e, queueMicrotask(ui);
+  }
+}, $e = 30, ci = (e) => !isNaN(parseFloat(e));
+class fi {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   *
+   * @internal
+   */
+  constructor(t, n = {}) {
+    this.version = "11.11.11", this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s, i = !0) => {
+      const r = B.now();
+      this.updatedAt !== r && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && this.events.change && this.events.change.notify(this.current), i && this.events.renderRequest && this.events.renderRequest.notify(this.current);
+    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = n.owner;
+  }
+  setCurrent(t) {
+    this.current = t, this.updatedAt = B.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = ci(this.current));
+  }
+  setPrevFrameValue(t = this.current) {
+    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(t) {
+    return process.env.NODE_ENV !== "production" && Ct(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", t);
+  }
+  on(t, n) {
+    this.events[t] || (this.events[t] = new Ln());
+    const s = this.events[t].add(n);
+    return t === "change" ? () => {
+      s(), M.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : s;
+  }
+  clearListeners() {
+    for (const t in this.events)
+      this.events[t].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   *
+   * @internal
+   */
+  attach(t, n) {
+    this.passiveEffect = t, this.stopPassiveEffect = n;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(t, n = !0) {
+    !n || !this.passiveEffect ? this.updateAndNotify(t, n) : this.passiveEffect(t, this.updateAndNotify);
+  }
+  setWithVelocity(t, n, s) {
+    this.set(n), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - s;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(t, n = !0) {
+    this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, n && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const t = B.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > $e)
+      return 0;
+    const n = Math.min(this.updatedAt - this.prevUpdatedAt, $e);
+    return ne(parseFloat(this.current) - parseFloat(this.prevFrameValue), n);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   *
+   * @internal
+   */
+  start(t) {
+    return this.stop(), new Promise((n) => {
+      this.hasAnimated = !0, this.animation = t(n), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function it(e, t) {
+  return new fi(e, t);
+}
+function Ft(e) {
+  let t;
+  return () => (t === void 0 && (t = e()), t);
+}
+const Nn = Ft(() => window.ScrollTimeline !== void 0);
+class se {
+  constructor(t) {
+    this.stop = () => this.runAll("stop"), this.animations = t.filter(Boolean);
+  }
+  then(t, n) {
+    return Promise.all(this.animations).then(t).catch(n);
+  }
+  /**
+   * TODO: Filter out cancelled or stopped animations before returning
+   */
+  getAll(t) {
+    return this.animations[0][t];
+  }
+  setAll(t, n) {
+    for (let s = 0; s < this.animations.length; s++)
+      this.animations[s][t] = n;
+  }
+  attachTimeline(t, n) {
+    const s = this.animations.map((i) => Nn() && i.attachTimeline ? i.attachTimeline(t) : n(i));
+    return () => {
+      s.forEach((i, r) => {
+        i && i(), this.animations[r].stop();
+      });
+    };
+  }
+  get time() {
+    return this.getAll("time");
+  }
+  set time(t) {
+    this.setAll("time", t);
+  }
+  get speed() {
+    return this.getAll("speed");
+  }
+  set speed(t) {
+    this.setAll("speed", t);
+  }
+  get startTime() {
+    return this.getAll("startTime");
+  }
+  get duration() {
+    let t = 0;
+    for (let n = 0; n < this.animations.length; n++)
+      t = Math.max(t, this.animations[n].duration);
+    return t;
+  }
+  runAll(t) {
+    this.animations.forEach((n) => n[t]());
+  }
+  play() {
+    this.runAll("play");
+  }
+  pause() {
+    this.runAll("pause");
+  }
+  cancel() {
+    this.runAll("cancel");
+  }
+  complete() {
+    this.runAll("complete");
+  }
+}
+const C = (e) => e * 1e3, D = (e) => e / 1e3, hi = 5;
+function $n(e, t, n) {
+  const s = Math.max(t - hi, 0);
+  return ne(n - e(s), t - s);
+}
+let ut = N, R = N;
+process.env.NODE_ENV !== "production" && (ut = (e, t) => {
+  !e && typeof console < "u" && console.warn(t);
+}, R = (e, t) => {
+  if (!e)
+    throw new Error(t);
+});
+const j = (e, t, n) => n > t ? t : n < e ? e : n, It = 1e-3, di = 0.01, Ke = 10, pi = 0.05, mi = 1;
+function gi({ duration: e = 800, bounce: t = 0.25, velocity: n = 0, mass: s = 1 }) {
+  let i, r;
+  ut(e <= C(Ke), "Spring duration must be 10 seconds or less");
+  let o = 1 - t;
+  o = j(pi, mi, o), e = j(di, Ke, D(e)), o < 1 ? (i = (u) => {
+    const c = u * o, f = c * e, h = c - n, p = _t(u, o), m = Math.exp(-f);
+    return It - h / p * m;
+  }, r = (u) => {
+    const f = u * o * e, h = f * n + n, p = Math.pow(o, 2) * Math.pow(u, 2) * e, m = Math.exp(-f), w = _t(Math.pow(u, 2), o);
+    return (-i(u) + It > 0 ? -1 : 1) * ((h - p) * m) / w;
+  }) : (i = (u) => {
+    const c = Math.exp(-u * e), f = (u - n) * e + 1;
+    return -It + c * f;
+  }, r = (u) => {
+    const c = Math.exp(-u * e), f = (n - u) * (e * e);
+    return c * f;
+  });
+  const a = 5 / e, l = vi(i, r, a);
+  if (e = C(e), isNaN(l))
+    return {
+      stiffness: 100,
+      damping: 10,
+      duration: e
+    };
+  {
+    const u = Math.pow(l, 2) * s;
+    return {
+      stiffness: u,
+      damping: o * 2 * Math.sqrt(s * u),
+      duration: e
+    };
+  }
+}
+const yi = 12;
+function vi(e, t, n) {
+  let s = n;
+  for (let i = 1; i < yi; i++)
+    s = s - e(s) / t(s);
+  return s;
+}
+function _t(e, t) {
+  return e * Math.sqrt(1 - t * t);
+}
+const bi = ["duration", "bounce"], wi = ["stiffness", "damping", "mass"];
+function We(e, t) {
+  return t.some((n) => e[n] !== void 0);
+}
+function Ti(e) {
+  let t = {
+    velocity: 0,
+    stiffness: 100,
+    damping: 10,
+    mass: 1,
+    isResolvedFromDuration: !1,
+    ...e
+  };
+  if (!We(e, wi) && We(e, bi)) {
+    const n = gi(e);
+    t = {
+      ...t,
+      ...n,
+      mass: 1
+    }, t.isResolvedFromDuration = !0;
+  }
+  return t;
+}
+function ie({ keyframes: e, restDelta: t, restSpeed: n, ...s }) {
+  const i = e[0], r = e[e.length - 1], o = { done: !1, value: i }, { stiffness: a, damping: l, mass: u, duration: c, velocity: f, isResolvedFromDuration: h } = Ti({
+    ...s,
+    velocity: -D(s.velocity || 0)
+  }), p = f || 0, m = l / (2 * Math.sqrt(a * u)), w = r - i, b = D(Math.sqrt(a / u)), g = Math.abs(w) < 5;
+  n || (n = g ? 0.01 : 2), t || (t = g ? 5e-3 : 0.5);
+  let y;
+  if (m < 1) {
+    const S = _t(b, m);
+    y = (x) => {
+      const T = Math.exp(-m * b * x);
+      return r - T * ((p + m * b * w) / S * Math.sin(S * x) + w * Math.cos(S * x));
+    };
+  } else if (m === 1)
+    y = (S) => r - Math.exp(-b * S) * (w + (p + b * w) * S);
+  else {
+    const S = b * Math.sqrt(m * m - 1);
+    y = (x) => {
+      const T = Math.exp(-m * b * x), A = Math.min(S * x, 300);
+      return r - T * ((p + m * b * w) * Math.sinh(A) + S * w * Math.cosh(A)) / S;
+    };
+  }
+  return {
+    calculatedDuration: h && c || null,
+    next: (S) => {
+      const x = y(S);
+      if (h)
+        o.done = S >= c;
+      else {
+        let T = 0;
+        m < 1 && (T = S === 0 ? C(p) : $n(y, S, x));
+        const A = Math.abs(T) <= n, F = Math.abs(r - x) <= t;
+        o.done = A && F;
+      }
+      return o.value = o.done ? r : x, o;
+    }
+  };
+}
+const Gt = 2e4;
+function Kn(e) {
+  let t = 0;
+  const n = 50;
+  let s = e.next(t);
+  for (; !s.done && t < Gt; )
+    t += n, s = e.next(t);
+  return t >= Gt ? 1 / 0 : t;
+}
+function Wn(e, t = 100, n) {
+  const s = n({ ...e, keyframes: [0, t] }), i = Math.min(Kn(s), Gt);
+  return {
+    type: "keyframes",
+    ease: (r) => s.next(i * r).value / t,
+    duration: D(i)
+  };
+}
+const ct = (e, t, n) => e + (t - e) * n, ft = (e, t, n) => {
+  const s = t - e;
+  return s === 0 ? 1 : (n - e) / s;
+};
+function _n(e, t) {
+  const n = e[e.length - 1];
+  for (let s = 1; s <= t; s++) {
+    const i = ft(0, t, s);
+    e.push(ct(n, 1, i));
+  }
+}
+function re(e) {
+  const t = [0];
+  return _n(t, e.length - 1), t;
+}
+const P = (e) => !!(e && e.getVelocity);
+function Ot(e, t, n) {
+  var s;
+  if (typeof e == "string") {
+    let i = document;
+    t && (R(!!t.current, "Scope provided, but no element detected."), i = t.current), n ? ((s = n[e]) !== null && s !== void 0 || (n[e] = i.querySelectorAll(e)), e = n[e]) : e = i.querySelectorAll(e);
+  } else e instanceof Element && (e = [e]);
+  return Array.from(e || []);
+}
+function oe(e) {
+  return typeof e == "object" && !Array.isArray(e);
+}
+function Gn(e, t, n, s) {
+  return typeof e == "string" && oe(t) ? Ot(e, n, s) : e instanceof NodeList ? Array.from(e) : Array.isArray(e) ? e : [e];
+}
+function ht(e) {
+  return typeof e == "function";
+}
+function _e(e, t, n, s) {
+  var i;
+  return typeof t == "number" ? t : t.startsWith("-") || t.startsWith("+") ? Math.max(0, e + parseFloat(t)) : t === "<" ? n : (i = s.get(t)) !== null && i !== void 0 ? i : e;
+}
+const Si = (e, t, n) => {
+  const s = t - e;
+  return ((n - e) % s + s) % s + e;
+}, kn = (e) => Array.isArray(e) && typeof e[0] != "number";
+function xi(e, t) {
+  return kn(e) ? e[Si(0, e.length, t)] : e;
+}
+function Vi(e, t, n) {
+  for (let s = 0; s < e.length; s++) {
+    const i = e[s];
+    i.at > t && i.at < n && (Bn(e, i), s--);
+  }
+}
+function Ai(e, t, n, s, i, r) {
+  Vi(e, i, r);
+  for (let o = 0; o < t.length; o++)
+    e.push({
+      value: t[o],
+      at: ct(i, r, s[o]),
+      easing: xi(n, o)
+    });
+}
+function Ei(e, t) {
+  return e.at === t.at ? e.value === null ? 1 : t.value === null ? -1 : 0 : e.at - t.at;
+}
+const Mi = "easeInOut";
+function Pi(e, { defaultTransition: t = {}, ...n } = {}, s, i) {
+  const r = t.duration || 0.3, o = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), l = {}, u = /* @__PURE__ */ new Map();
+  let c = 0, f = 0, h = 0;
+  for (let p = 0; p < e.length; p++) {
+    const m = e[p];
+    if (typeof m == "string") {
+      u.set(m, f);
+      continue;
+    } else if (!Array.isArray(m)) {
+      u.set(m.name, _e(f, m.at, c, u));
+      continue;
+    }
+    let [w, b, g = {}] = m;
+    g.at !== void 0 && (f = _e(f, g.at, c, u));
+    let y = 0;
+    const S = (x, T, A, F = 0, v = 0) => {
+      const V = Ci(x), { delay: O = 0, times: G = re(V), type: Dt = "keyframes", ...Gs } = T;
+      let { ease: Me = t.ease || "easeOut", duration: I } = T;
+      const Pe = typeof O == "function" ? O(F, v) : O, Ce = V.length, Fe = ht(Dt) ? Dt : i == null ? void 0 : i[Dt];
+      if (Ce <= 2 && Fe) {
+        let Ie = 100;
+        if (Ce === 2 && Di(V)) {
+          const ks = V[1] - V[0];
+          Ie = Math.abs(ks);
+        }
+        const Be = { ...Gs };
+        I !== void 0 && (Be.duration = C(I));
+        const Le = Wn(Be, Ie, Fe);
+        Me = Le.ease, I = Le.duration;
+      }
+      I ?? (I = r);
+      const Oe = f + Pe, De = Oe + I;
+      G.length === 1 && G[0] === 0 && (G[1] = 1);
+      const Re = G.length - V.length;
+      Re > 0 && _n(G, Re), V.length === 1 && V.unshift(null), Ai(A, V, Me, G, Oe, De), y = Math.max(Pe + I, y), h = Math.max(De, h);
+    };
+    if (P(w)) {
+      const x = Ge(w, a);
+      S(b, g, ke("default", x));
+    } else {
+      const x = Gn(w, b, s, l), T = x.length;
+      for (let A = 0; A < T; A++) {
+        b = b, g = g;
+        const F = x[A], v = Ge(F, a);
+        for (const V in b)
+          S(b[V], Fi(g, V), ke(V, v), A, T);
+      }
+    }
+    c = f, f += y;
+  }
+  return a.forEach((p, m) => {
+    for (const w in p) {
+      const b = p[w];
+      b.sort(Ei);
+      const g = [], y = [], S = [];
+      for (let T = 0; T < b.length; T++) {
+        const { at: A, value: F, easing: v } = b[T];
+        g.push(F), y.push(ft(0, h, A)), S.push(v || "easeOut");
+      }
+      y[0] !== 0 && (y.unshift(0), g.unshift(g[0]), S.unshift(Mi)), y[y.length - 1] !== 1 && (y.push(1), g.push(null)), o.has(m) || o.set(m, {
+        keyframes: {},
+        transition: {}
+      });
+      const x = o.get(m);
+      x.keyframes[w] = g, x.transition[w] = {
+        ...t,
+        duration: h,
+        ease: S,
+        times: y,
+        ...n
+      };
+    }
+  }), o;
+}
+function Ge(e, t) {
+  return !t.has(e) && t.set(e, {}), t.get(e);
+}
+function ke(e, t) {
+  return t[e] || (t[e] = []), t[e];
+}
+function Ci(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function Fi(e, t) {
+  return e && e[t] ? {
+    ...e,
+    ...e[t]
+  } : { ...e };
+}
+const Oi = (e) => typeof e == "number", Di = (e) => e.every(Oi), L = /* @__PURE__ */ new WeakMap(), dt = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], U = new Set(dt), Ri = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, Ii = (e) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: e === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), Bi = {
+  type: "keyframes",
+  duration: 0.8
+}, Li = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, Ni = (e, { keyframes: t }) => t.length > 2 ? Bi : U.has(e) ? e.startsWith("scale") ? Ii(t[1]) : Ri : Li;
+function ae(e, t) {
+  return e ? e[t] || e.default || e : void 0;
+}
+const $i = (e) => e !== null;
+function pt(e, { repeat: t, repeatType: n = "loop" }, s) {
+  const i = e.filter($i), r = t && n !== "loop" && t % 2 === 1 ? 0 : i.length - 1;
+  return !r || s === void 0 ? i[r] : s;
+}
+const zn = (e, t, n) => (((1 - 3 * n + 3 * t) * e + (3 * n - 6 * t)) * e + 3 * t) * e, Ki = 1e-7, Wi = 12;
+function _i(e, t, n, s, i) {
+  let r, o, a = 0;
+  do
+    o = t + (n - t) / 2, r = zn(o, s, i) - e, r > 0 ? n = o : t = o;
+  while (Math.abs(r) > Ki && ++a < Wi);
+  return o;
+}
+function mt(e, t, n, s) {
+  if (e === t && n === s)
+    return N;
+  const i = (r) => _i(r, 0, 1, e, n);
+  return (r) => r === 0 || r === 1 ? r : zn(i(r), t, s);
+}
+const jn = (e) => (t) => t <= 0.5 ? e(2 * t) / 2 : (2 - e(2 * (1 - t))) / 2, Un = (e) => (t) => 1 - e(1 - t), Hn = /* @__PURE__ */ mt(0.33, 1.53, 0.69, 0.99), le = /* @__PURE__ */ Un(Hn), qn = /* @__PURE__ */ jn(le), Yn = (e) => (e *= 2) < 1 ? 0.5 * le(e) : 0.5 * (2 - Math.pow(2, -10 * (e - 1))), ue = (e) => 1 - Math.sin(Math.acos(e)), Gi = Un(ue), Xn = jn(ue), Zn = (e) => /^0[^.\s]+$/u.test(e);
+function ki(e) {
+  return typeof e == "number" ? e === 0 : e !== null ? e === "none" || e === "0" || Zn(e) : !0;
+}
+const Qn = (e) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(e), Jn = (e) => (t) => typeof t == "string" && t.startsWith(e), ts = /* @__PURE__ */ Jn("--"), zi = /* @__PURE__ */ Jn("var(--"), ce = (e) => zi(e) ? ji.test(e.split("/*")[0].trim()) : !1, ji = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu, 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 Hi(e) {
+  const t = Ui.exec(e);
+  if (!t)
+    return [,];
+  const [, n, s, i] = t;
+  return [`--${n ?? s}`, i];
+}
+const qi = 4;
+function es(e, t, n = 1) {
+  R(n <= qi, `Max CSS variable fallback depth detected in property "${e}". This may indicate a circular fallback dependency.`);
+  const [s, i] = Hi(e);
+  if (!s)
+    return;
+  const r = window.getComputedStyle(t).getPropertyValue(s);
+  if (r) {
+    const o = r.trim();
+    return Qn(o) ? parseFloat(o) : o;
+  }
+  return ce(i) ? es(i, t, n + 1) : i;
+}
+const X = {
+  test: (e) => typeof e == "number",
+  parse: parseFloat,
+  transform: (e) => e
+}, rt = {
+  ...X,
+  transform: (e) => j(0, 1, e)
+}, yt = {
+  ...X,
+  default: 1
+}, gt = (e) => ({
+  test: (t) => typeof t == "string" && t.endsWith(e) && t.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (t) => `${t}${e}`
+}), $ = /* @__PURE__ */ gt("deg"), q = /* @__PURE__ */ gt("%"), d = /* @__PURE__ */ gt("px"), Yi = /* @__PURE__ */ gt("vh"), Xi = /* @__PURE__ */ gt("vw"), ze = {
+  ...q,
+  parse: (e) => q.parse(e) / 100,
+  transform: (e) => q.transform(e * 100)
+}, Zi = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "x",
+  "y",
+  "translateX",
+  "translateY"
+]), je = (e) => e === X || e === d, Ue = (e, t) => parseFloat(e.split(", ")[t]), He = (e, t) => (n, { transform: s }) => {
+  if (s === "none" || !s)
+    return 0;
+  const i = s.match(/^matrix3d\((.+)\)$/u);
+  if (i)
+    return Ue(i[1], t);
+  {
+    const r = s.match(/^matrix\((.+)\)$/u);
+    return r ? Ue(r[1], e) : 0;
+  }
+}, Qi = /* @__PURE__ */ new Set(["x", "y", "z"]), Ji = dt.filter((e) => !Qi.has(e));
+function tr(e) {
+  const t = [];
+  return Ji.forEach((n) => {
+    const s = e.getValue(n);
+    s !== void 0 && (t.push([n, s.get()]), s.set(n.startsWith("scale") ? 1 : 0));
+  }), t;
+}
+const Y = {
+  // Dimensions
+  width: ({ x: e }, { paddingLeft: t = "0", paddingRight: n = "0" }) => e.max - e.min - parseFloat(t) - parseFloat(n),
+  height: ({ y: e }, { paddingTop: t = "0", paddingBottom: n = "0" }) => e.max - e.min - parseFloat(t) - parseFloat(n),
+  top: (e, { top: t }) => parseFloat(t),
+  left: (e, { left: t }) => parseFloat(t),
+  bottom: ({ y: e }, { top: t }) => parseFloat(t) + (e.max - e.min),
+  right: ({ x: e }, { left: t }) => parseFloat(t) + (e.max - e.min),
+  // Transform
+  x: He(4, 13),
+  y: He(5, 14)
+};
+Y.translateX = Y.x;
+Y.translateY = Y.y;
+const ns = (e) => (t) => t.test(e), er = {
+  test: (e) => e === "auto",
+  parse: (e) => e
+}, ss = [X, d, q, $, Xi, Yi, er], qe = (e) => ss.find(ns(e)), z = /* @__PURE__ */ new Set();
+let kt = !1, zt = !1;
+function is() {
+  if (zt) {
+    const e = Array.from(z).filter((s) => s.needsMeasurement), t = new Set(e.map((s) => s.element)), n = /* @__PURE__ */ new Map();
+    t.forEach((s) => {
+      const i = tr(s);
+      i.length && (n.set(s, i), s.render());
+    }), e.forEach((s) => s.measureInitialState()), t.forEach((s) => {
+      s.render();
+      const i = n.get(s);
+      i && i.forEach(([r, o]) => {
+        var a;
+        (a = s.getValue(r)) === null || a === void 0 || a.set(o);
+      });
+    }), e.forEach((s) => s.measureEndState()), e.forEach((s) => {
+      s.suspendedScrollY !== void 0 && window.scrollTo(0, s.suspendedScrollY);
+    });
+  }
+  zt = !1, kt = !1, z.forEach((e) => e.complete()), z.clear();
+}
+function rs() {
+  z.forEach((e) => {
+    e.readKeyframes(), e.needsMeasurement && (zt = !0);
+  });
+}
+function nr() {
+  rs(), is();
+}
+class fe {
+  constructor(t, n, s, i, r, o = !1) {
+    this.isComplete = !1, this.isAsync = !1, this.needsMeasurement = !1, this.isScheduled = !1, this.unresolvedKeyframes = [...t], this.onComplete = n, this.name = s, this.motionValue = i, this.element = r, this.isAsync = o;
+  }
+  scheduleResolve() {
+    this.isScheduled = !0, this.isAsync ? (z.add(this), kt || (kt = !0, M.read(rs), M.resolveKeyframes(is))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: t, name: n, element: s, motionValue: i } = this;
+    for (let r = 0; r < t.length; r++)
+      if (t[r] === null)
+        if (r === 0) {
+          const o = i == null ? void 0 : i.get(), a = t[t.length - 1];
+          if (o !== void 0)
+            t[0] = o;
+          else if (s && n) {
+            const l = s.readValue(n, a);
+            l != null && (t[0] = l);
+          }
+          t[0] === void 0 && (t[0] = a), i && o === void 0 && i.set(t[0]);
+        } else
+          t[r] = t[r - 1];
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete() {
+    this.isComplete = !0, this.onComplete(this.unresolvedKeyframes, this.finalKeyframe), z.delete(this);
+  }
+  cancel() {
+    this.isComplete || (this.isScheduled = !1, z.delete(this));
+  }
+  resume() {
+    this.isComplete || this.scheduleResolve();
+  }
+}
+const et = (e) => Math.round(e * 1e5) / 1e5, he = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function sr(e) {
+  return e == null;
+}
+const ir = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, de = (e, t) => (n) => !!(typeof n == "string" && ir.test(n) && n.startsWith(e) || t && !sr(n) && Object.prototype.hasOwnProperty.call(n, t)), os = (e, t, n) => (s) => {
+  if (typeof s != "string")
+    return s;
+  const [i, r, o, a] = s.match(he);
+  return {
+    [e]: parseFloat(i),
+    [t]: parseFloat(r),
+    [n]: parseFloat(o),
+    alpha: a !== void 0 ? parseFloat(a) : 1
+  };
+}, rr = (e) => j(0, 255, e), Bt = {
+  ...X,
+  transform: (e) => Math.round(rr(e))
+}, k = {
+  test: /* @__PURE__ */ de("rgb", "red"),
+  parse: /* @__PURE__ */ os("red", "green", "blue"),
+  transform: ({ red: e, green: t, blue: n, alpha: s = 1 }) => "rgba(" + Bt.transform(e) + ", " + Bt.transform(t) + ", " + Bt.transform(n) + ", " + et(rt.transform(s)) + ")"
+};
+function or(e) {
+  let t = "", n = "", s = "", i = "";
+  return e.length > 5 ? (t = e.substring(1, 3), n = e.substring(3, 5), s = e.substring(5, 7), i = e.substring(7, 9)) : (t = e.substring(1, 2), n = e.substring(2, 3), s = e.substring(3, 4), i = e.substring(4, 5), t += t, n += n, s += s, i += i), {
+    red: parseInt(t, 16),
+    green: parseInt(n, 16),
+    blue: parseInt(s, 16),
+    alpha: i ? parseInt(i, 16) / 255 : 1
+  };
+}
+const jt = {
+  test: /* @__PURE__ */ de("#"),
+  parse: or,
+  transform: k.transform
+}, H = {
+  test: /* @__PURE__ */ de("hsl", "hue"),
+  parse: /* @__PURE__ */ os("hue", "saturation", "lightness"),
+  transform: ({ hue: e, saturation: t, lightness: n, alpha: s = 1 }) => "hsla(" + Math.round(e) + ", " + q.transform(et(t)) + ", " + q.transform(et(n)) + ", " + et(rt.transform(s)) + ")"
+}, E = {
+  test: (e) => k.test(e) || jt.test(e) || H.test(e),
+  parse: (e) => k.test(e) ? k.parse(e) : H.test(e) ? H.parse(e) : jt.parse(e),
+  transform: (e) => typeof e == "string" ? e : e.hasOwnProperty("red") ? k.transform(e) : H.transform(e)
+}, ar = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+function lr(e) {
+  var t, n;
+  return isNaN(e) && typeof e == "string" && (((t = e.match(he)) === null || t === void 0 ? void 0 : t.length) || 0) + (((n = e.match(ar)) === null || n === void 0 ? void 0 : n.length) || 0) > 0;
+}
+const as = "number", ls = "color", ur = "var", cr = "var(", Ye = "${}", fr = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function ot(e) {
+  const t = e.toString(), n = [], s = {
+    color: [],
+    number: [],
+    var: []
+  }, i = [];
+  let r = 0;
+  const a = t.replace(fr, (l) => (E.test(l) ? (s.color.push(r), i.push(ls), n.push(E.parse(l))) : l.startsWith(cr) ? (s.var.push(r), i.push(ur), n.push(l)) : (s.number.push(r), i.push(as), n.push(parseFloat(l))), ++r, Ye)).split(Ye);
+  return { values: n, split: a, indexes: s, types: i };
+}
+function us(e) {
+  return ot(e).values;
+}
+function cs(e) {
+  const { split: t, types: n } = ot(e), s = t.length;
+  return (i) => {
+    let r = "";
+    for (let o = 0; o < s; o++)
+      if (r += t[o], i[o] !== void 0) {
+        const a = n[o];
+        a === as ? r += et(i[o]) : a === ls ? r += E.transform(i[o]) : r += i[o];
+      }
+    return r;
+  };
+}
+const hr = (e) => typeof e == "number" ? 0 : e;
+function dr(e) {
+  const t = us(e);
+  return cs(e)(t.map(hr));
+}
+const Z = {
+  test: lr,
+  parse: us,
+  createTransformer: cs,
+  getAnimatableNone: dr
+}, pr = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function mr(e) {
+  const [t, n] = e.slice(0, -1).split("(");
+  if (t === "drop-shadow")
+    return e;
+  const [s] = n.match(he) || [];
+  if (!s)
+    return e;
+  const i = n.replace(s, "");
+  let r = pr.has(t) ? 1 : 0;
+  return s !== n && (r *= 100), t + "(" + r + i + ")";
+}
+const gr = /\b([a-z-]*)\(.*?\)/gu, Ut = {
+  ...Z,
+  getAnimatableNone: (e) => {
+    const t = e.match(gr);
+    return t ? t.map(mr).join(" ") : e;
+  }
+}, Ht = {
+  // Border props
+  borderWidth: d,
+  borderTopWidth: d,
+  borderRightWidth: d,
+  borderBottomWidth: d,
+  borderLeftWidth: d,
+  borderRadius: d,
+  radius: d,
+  borderTopLeftRadius: d,
+  borderTopRightRadius: d,
+  borderBottomRightRadius: d,
+  borderBottomLeftRadius: d,
+  // Positioning props
+  width: d,
+  maxWidth: d,
+  height: d,
+  maxHeight: d,
+  top: d,
+  right: d,
+  bottom: d,
+  left: d,
+  // Spacing props
+  padding: d,
+  paddingTop: d,
+  paddingRight: d,
+  paddingBottom: d,
+  paddingLeft: d,
+  margin: d,
+  marginTop: d,
+  marginRight: d,
+  marginBottom: d,
+  marginLeft: d,
+  // Misc
+  backgroundPositionX: d,
+  backgroundPositionY: d
+}, yr = {
+  rotate: $,
+  rotateX: $,
+  rotateY: $,
+  rotateZ: $,
+  scale: yt,
+  scaleX: yt,
+  scaleY: yt,
+  scaleZ: yt,
+  skew: $,
+  skewX: $,
+  skewY: $,
+  distance: d,
+  translateX: d,
+  translateY: d,
+  translateZ: d,
+  x: d,
+  y: d,
+  z: d,
+  perspective: d,
+  transformPerspective: d,
+  opacity: rt,
+  originX: ze,
+  originY: ze,
+  originZ: d
+}, Xe = {
+  ...X,
+  transform: Math.round
+}, pe = {
+  ...Ht,
+  ...yr,
+  zIndex: Xe,
+  size: d,
+  // SVG
+  fillOpacity: rt,
+  strokeOpacity: rt,
+  numOctaves: Xe
+}, vr = {
+  ...pe,
+  // Color props
+  color: E,
+  backgroundColor: E,
+  outlineColor: E,
+  fill: E,
+  stroke: E,
+  // Border props
+  borderColor: E,
+  borderTopColor: E,
+  borderRightColor: E,
+  borderBottomColor: E,
+  borderLeftColor: E,
+  filter: Ut,
+  WebkitFilter: Ut
+}, me = (e) => vr[e];
+function fs(e, t) {
+  let n = me(e);
+  return n !== Ut && (n = Z), n.getAnimatableNone ? n.getAnimatableNone(t) : void 0;
+}
+const br = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function wr(e, t, n) {
+  let s = 0, i;
+  for (; s < e.length && !i; ) {
+    const r = e[s];
+    typeof r == "string" && !br.has(r) && ot(r).values.length && (i = e[s]), s++;
+  }
+  if (i && n)
+    for (const r of t)
+      e[r] = fs(n, i);
+}
+class hs extends fe {
+  constructor(t, n, s, i, r) {
+    super(t, n, s, i, r, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: t, element: n, name: s } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let l = 0; l < t.length; l++) {
+      let u = t[l];
+      if (typeof u == "string" && (u = u.trim(), ce(u))) {
+        const c = es(u, n.current);
+        c !== void 0 && (t[l] = c), l === t.length - 1 && (this.finalKeyframe = u);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !Zi.has(s) || t.length !== 2)
+      return;
+    const [i, r] = t, o = qe(i), a = qe(r);
+    if (o !== a)
+      if (je(o) && je(a))
+        for (let l = 0; l < t.length; l++) {
+          const u = t[l];
+          typeof u == "string" && (t[l] = parseFloat(u));
+        }
+      else
+        this.needsMeasurement = !0;
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: t, name: n } = this, s = [];
+    for (let i = 0; i < t.length; i++)
+      ki(t[i]) && s.push(i);
+    s.length && wr(t, s, n);
+  }
+  measureInitialState() {
+    const { element: t, unresolvedKeyframes: n, name: s } = this;
+    if (!t || !t.current)
+      return;
+    s === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = Y[s](t.measureViewportBox(), window.getComputedStyle(t.current)), n[0] = this.measuredOrigin;
+    const i = n[n.length - 1];
+    i !== void 0 && t.getValue(s, i).jump(i, !1);
+  }
+  measureEndState() {
+    var t;
+    const { element: n, name: s, unresolvedKeyframes: i } = this;
+    if (!n || !n.current)
+      return;
+    const r = n.getValue(s);
+    r && r.jump(this.measuredOrigin, !1);
+    const o = i.length - 1, a = i[o];
+    i[o] = Y[s](n.measureViewportBox(), window.getComputedStyle(n.current)), a !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = a), !((t = this.removedTransforms) === null || t === void 0) && t.length && this.removedTransforms.forEach(([l, u]) => {
+      n.getValue(l).set(u);
+    }), this.resolveNoneKeyframes();
+  }
+}
+const Ze = (e, t) => t === "zIndex" ? !1 : !!(typeof e == "number" || Array.isArray(e) || typeof e == "string" && // It's animatable if we have a string
+(Z.test(e) || e === "0") && // And it contains numbers and/or colors
+!e.startsWith("url("));
+function Tr(e) {
+  const t = e[0];
+  if (e.length === 1)
+    return !0;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t)
+      return !0;
+}
+function Sr(e, t, n, s) {
+  const i = e[0];
+  if (i === null)
+    return !1;
+  if (t === "display" || t === "visibility")
+    return !0;
+  const r = e[e.length - 1], o = Ze(i, t), a = Ze(r, t);
+  return ut(o === a, `You are trying to animate ${t} from "${i}" to "${r}". ${i} is not an animatable value - to enable this animation set ${i} to a value animatable to ${r} via the \`style\` property.`), !o || !a ? !1 : Tr(e) || (n === "spring" || ht(n)) && s;
+}
+const xr = 40;
+class ds {
+  constructor({ autoplay: t = !0, delay: n = 0, type: s = "keyframes", repeat: i = 0, repeatDelay: r = 0, repeatType: o = "loop", ...a }) {
+    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = B.now(), this.options = {
+      autoplay: t,
+      delay: n,
+      type: s,
+      repeat: i,
+      repeatDelay: r,
+      repeatType: o,
+      ...a
+    }, this.updateFinishedPromise();
+  }
+  /**
+   * This method uses the createdAt and resolvedAt to calculate the
+   * animation startTime. *Ideally*, we would use the createdAt time as t=0
+   * as the following frame would then be the first frame of the animation in
+   * progress, which would feel snappier.
+   *
+   * However, if there's a delay (main thread work) between the creation of
+   * the animation and the first commited frame, we prefer to use resolvedAt
+   * to avoid a sudden jump into the animation.
+   */
+  calcStartTime() {
+    return this.resolvedAt ? this.resolvedAt - this.createdAt > xr ? this.resolvedAt : this.createdAt : this.createdAt;
+  }
+  /**
+   * A getter for resolved data. If keyframes are not yet resolved, accessing
+   * this.resolved will synchronously flush all pending keyframe resolvers.
+   * This is a deoptimisation, but at its worst still batches read/writes.
+   */
+  get resolved() {
+    return !this._resolved && !this.hasAttemptedResolve && nr(), this._resolved;
+  }
+  /**
+   * A method to be called when the keyframes resolver completes. This method
+   * will check if its possible to run the animation and, if not, skip it.
+   * Otherwise, it will call initPlayback on the implementing class.
+   */
+  onKeyframesResolved(t, n) {
+    this.resolvedAt = B.now(), this.hasAttemptedResolve = !0;
+    const { name: s, type: i, velocity: r, delay: o, onComplete: a, onUpdate: l, isGenerator: u } = this.options;
+    if (!u && !Sr(t, s, i, r))
+      if (o)
+        this.options.duration = 0;
+      else {
+        l == null || l(pt(t, this.options, n)), a == null || a(), this.resolveFinishedPromise();
+        return;
+      }
+    const c = this.initPlayback(t, n);
+    c !== !1 && (this._resolved = {
+      keyframes: t,
+      finalKeyframe: n,
+      ...c
+    }, this.onPostResolved());
+  }
+  onPostResolved() {
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(t, n) {
+    return this.currentFinishedPromise.then(t, n);
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((t) => {
+      this.resolveFinishedPromise = t;
+    });
+  }
+}
+function Qe({ keyframes: e, velocity: t = 0, power: n = 0.8, timeConstant: s = 325, bounceDamping: i = 10, bounceStiffness: r = 500, modifyTarget: o, min: a, max: l, restDelta: u = 0.5, restSpeed: c }) {
+  const f = e[0], h = {
+    done: !1,
+    value: f
+  }, p = (v) => a !== void 0 && v < a || l !== void 0 && v > l, m = (v) => a === void 0 ? l : l === void 0 || Math.abs(a - v) < Math.abs(l - v) ? a : l;
+  let w = n * t;
+  const b = f + w, g = o === void 0 ? b : o(b);
+  g !== b && (w = g - f);
+  const y = (v) => -w * Math.exp(-v / s), S = (v) => g + y(v), x = (v) => {
+    const V = y(v), O = S(v);
+    h.done = Math.abs(V) <= u, h.value = h.done ? g : O;
+  };
+  let T, A;
+  const F = (v) => {
+    p(h.value) && (T = v, A = ie({
+      keyframes: [h.value, m(h.value)],
+      velocity: $n(S, v, h.value),
+      // TODO: This should be passing * 1000
+      damping: i,
+      stiffness: r,
+      restDelta: u,
+      restSpeed: c
+    }));
+  };
+  return F(0), {
+    calculatedDuration: null,
+    next: (v) => {
+      let V = !1;
+      return !A && T === void 0 && (V = !0, x(v), F(v)), T !== void 0 && v >= T ? A.next(v - T) : (!V && x(v), h);
+    }
+  };
+}
+const Vr = /* @__PURE__ */ mt(0.42, 0, 1, 1), Ar = /* @__PURE__ */ mt(0, 0, 0.58, 1), ps = /* @__PURE__ */ mt(0.42, 0, 0.58, 1), ge = (e) => Array.isArray(e) && typeof e[0] == "number", Je = {
+  linear: N,
+  easeIn: Vr,
+  easeInOut: ps,
+  easeOut: Ar,
+  circIn: ue,
+  circInOut: Xn,
+  circOut: Gi,
+  backIn: le,
+  backInOut: qn,
+  backOut: Hn,
+  anticipate: Yn
+}, qt = (e) => {
+  if (ge(e)) {
+    R(e.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [t, n, s, i] = e;
+    return mt(t, n, s, i);
+  } else if (typeof e == "string")
+    return R(Je[e] !== void 0, `Invalid easing type '${e}'`), Je[e];
+  return e;
+}, Er = (e, t) => (n) => t(e(n)), ye = (...e) => e.reduce(Er);
+function Lt(e, t, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? e + (t - e) * 6 * n : n < 1 / 2 ? t : n < 2 / 3 ? e + (t - e) * (2 / 3 - n) * 6 : e;
+}
+function Mr({ hue: e, saturation: t, lightness: n, alpha: s }) {
+  e /= 360, t /= 100, n /= 100;
+  let i = 0, r = 0, o = 0;
+  if (!t)
+    i = r = o = n;
+  else {
+    const a = n < 0.5 ? n * (1 + t) : n + t - n * t, l = 2 * n - a;
+    i = Lt(l, a, e + 1 / 3), r = Lt(l, a, e), o = Lt(l, a, e - 1 / 3);
+  }
+  return {
+    red: Math.round(i * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(o * 255),
+    alpha: s
+  };
+}
+function St(e, t) {
+  return (n) => n > 0 ? t : e;
+}
+const Nt = (e, t, n) => {
+  const s = e * e, i = n * (t * t - s) + s;
+  return i < 0 ? 0 : Math.sqrt(i);
+}, Pr = [jt, k, H], Cr = (e) => Pr.find((t) => t.test(e));
+function tn(e) {
+  const t = Cr(e);
+  if (ut(!!t, `'${e}' is not an animatable color. Use the equivalent color code instead.`), !t)
+    return !1;
+  let n = t.parse(e);
+  return t === H && (n = Mr(n)), n;
+}
+const en = (e, t) => {
+  const n = tn(e), s = tn(t);
+  if (!n || !s)
+    return St(e, t);
+  const i = { ...n };
+  return (r) => (i.red = Nt(n.red, s.red, r), i.green = Nt(n.green, s.green, r), i.blue = Nt(n.blue, s.blue, r), i.alpha = ct(n.alpha, s.alpha, r), k.transform(i));
+}, Yt = /* @__PURE__ */ new Set(["none", "hidden"]);
+function Fr(e, t) {
+  return Yt.has(e) ? (n) => n <= 0 ? e : t : (n) => n >= 1 ? t : e;
+}
+function Or(e, t) {
+  return (n) => ct(e, t, n);
+}
+function ve(e) {
+  return typeof e == "number" ? Or : typeof e == "string" ? ce(e) ? St : E.test(e) ? en : Ir : Array.isArray(e) ? ms : typeof e == "object" ? E.test(e) ? en : Dr : St;
+}
+function ms(e, t) {
+  const n = [...e], s = n.length, i = e.map((r, o) => ve(r)(r, t[o]));
+  return (r) => {
+    for (let o = 0; o < s; o++)
+      n[o] = i[o](r);
+    return n;
+  };
+}
+function Dr(e, t) {
+  const n = { ...e, ...t }, s = {};
+  for (const i in n)
+    e[i] !== void 0 && t[i] !== void 0 && (s[i] = ve(e[i])(e[i], t[i]));
+  return (i) => {
+    for (const r in s)
+      n[r] = s[r](i);
+    return n;
+  };
+}
+function Rr(e, t) {
+  var n;
+  const s = [], i = { color: 0, var: 0, number: 0 };
+  for (let r = 0; r < t.values.length; r++) {
+    const o = t.types[r], a = e.indexes[o][i[o]], l = (n = e.values[a]) !== null && n !== void 0 ? n : 0;
+    s[r] = l, i[o]++;
+  }
+  return s;
+}
+const Ir = (e, t) => {
+  const n = Z.createTransformer(t), s = ot(e), i = ot(t);
+  return s.indexes.var.length === i.indexes.var.length && s.indexes.color.length === i.indexes.color.length && s.indexes.number.length >= i.indexes.number.length ? Yt.has(e) && !i.values.length || Yt.has(t) && !s.values.length ? Fr(e, t) : ye(ms(Rr(s, i), i.values), n) : (ut(!0, `Complex values '${e}' and '${t}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`), St(e, t));
+};
+function gs(e, t, n) {
+  return typeof e == "number" && typeof t == "number" && typeof n == "number" ? ct(e, t, n) : ve(e)(e, t);
+}
+function Br(e, t, n) {
+  const s = [], i = n || gs, r = e.length - 1;
+  for (let o = 0; o < r; o++) {
+    let a = i(e[o], e[o + 1]);
+    if (t) {
+      const l = Array.isArray(t) ? t[o] || N : t;
+      a = ye(l, a);
+    }
+    s.push(a);
+  }
+  return s;
+}
+function be(e, t, { clamp: n = !0, ease: s, mixer: i } = {}) {
+  const r = e.length;
+  if (R(r === t.length, "Both input and output ranges must be the same length"), r === 1)
+    return () => t[0];
+  if (r === 2 && e[0] === e[1])
+    return () => t[1];
+  e[0] > e[r - 1] && (e = [...e].reverse(), t = [...t].reverse());
+  const o = Br(t, s, i), a = o.length, l = (u) => {
+    let c = 0;
+    if (a > 1)
+      for (; c < e.length - 2 && !(u < e[c + 1]); c++)
+        ;
+    const f = ft(e[c], e[c + 1], u);
+    return o[c](f);
+  };
+  return n ? (u) => l(j(e[0], e[r - 1], u)) : l;
+}
+function Lr(e, t) {
+  return e.map((n) => n * t);
+}
+function Nr(e, t) {
+  return e.map(() => t || ps).splice(0, e.length - 1);
+}
+function xt({ duration: e = 300, keyframes: t, times: n, ease: s = "easeInOut" }) {
+  const i = kn(s) ? s.map(qt) : qt(s), r = {
+    done: !1,
+    value: t[0]
+  }, o = Lr(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    n && n.length === t.length ? n : re(t),
+    e
+  ), a = be(o, t, {
+    ease: Array.isArray(i) ? i : Nr(t, i)
+  });
+  return {
+    calculatedDuration: e,
+    next: (l) => (r.value = a(l), r.done = l >= e, r)
+  };
+}
+const $r = (e) => {
+  const t = ({ timestamp: n }) => e(n);
+  return {
+    start: () => M.update(t, !0),
+    stop: () => _(t),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => st.isProcessing ? st.timestamp : B.now()
+  };
+}, Kr = {
+  decay: Qe,
+  inertia: Qe,
+  tween: xt,
+  keyframes: xt,
+  spring: ie
+}, Wr = (e) => e / 100;
+class we extends ds {
+  constructor(t) {
+    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
+      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop: l } = this.options;
+      l && l();
+    };
+    const { name: n, motionValue: s, element: i, keyframes: r } = this.options, o = (i == null ? void 0 : i.KeyframeResolver) || fe, a = (l, u) => this.onKeyframesResolved(l, u);
+    this.resolver = new o(r, a, n, s, i), this.resolver.scheduleResolve();
+  }
+  initPlayback(t) {
+    const { type: n = "keyframes", repeat: s = 0, repeatDelay: i = 0, repeatType: r, velocity: o = 0 } = this.options, a = ht(n) ? n : Kr[n] || xt;
+    let l, u;
+    a !== xt && typeof t[0] != "number" && (process.env.NODE_ENV !== "production" && R(t.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), l = ye(Wr, gs(t[0], t[1])), t = [0, 100]);
+    const c = a({ ...this.options, keyframes: t });
+    r === "mirror" && (u = a({
+      ...this.options,
+      keyframes: [...t].reverse(),
+      velocity: -o
+    })), c.calculatedDuration === null && (c.calculatedDuration = Kn(c));
+    const { calculatedDuration: f } = c, h = f + i, p = h * (s + 1) - i;
+    return {
+      generator: c,
+      mirroredGenerator: u,
+      mapPercentToKeyframes: l,
+      calculatedDuration: f,
+      resolvedDuration: h,
+      totalDuration: p
+    };
+  }
+  onPostResolved() {
+    const { autoplay: t = !0 } = this.options;
+    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
+  }
+  tick(t, n = !1) {
+    const { resolved: s } = this;
+    if (!s) {
+      const { keyframes: v } = this.options;
+      return { done: !0, value: v[v.length - 1] };
+    }
+    const { finalKeyframe: i, generator: r, mirroredGenerator: o, mapPercentToKeyframes: a, keyframes: l, calculatedDuration: u, totalDuration: c, resolvedDuration: f } = s;
+    if (this.startTime === null)
+      return r.next(0);
+    const { delay: h, repeat: p, repeatType: m, repeatDelay: w, onUpdate: b } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - c / this.speed, this.startTime)), n ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
+    const g = this.currentTime - h * (this.speed >= 0 ? 1 : -1), y = this.speed >= 0 ? g < 0 : g > c;
+    this.currentTime = Math.max(g, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = c);
+    let S = this.currentTime, x = r;
+    if (p) {
+      const v = Math.min(this.currentTime, c) / f;
+      let V = Math.floor(v), O = v % 1;
+      !O && v >= 1 && (O = 1), O === 1 && V--, V = Math.min(V, p + 1), !!(V % 2) && (m === "reverse" ? (O = 1 - O, w && (O -= w / f)) : m === "mirror" && (x = o)), S = j(0, 1, O) * f;
+    }
+    const T = y ? { done: !1, value: l[0] } : x.next(S);
+    a && (T.value = a(T.value));
+    let { done: A } = T;
+    !y && u !== null && (A = this.speed >= 0 ? this.currentTime >= c : this.currentTime <= 0);
+    const F = this.holdTime === null && (this.state === "finished" || this.state === "running" && A);
+    return F && i !== void 0 && (T.value = pt(l, this.options, i)), b && b(T.value), F && this.finish(), T;
+  }
+  get duration() {
+    const { resolved: t } = this;
+    return t ? D(t.calculatedDuration) : 0;
+  }
+  get time() {
+    return D(this.currentTime);
+  }
+  set time(t) {
+    t = C(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const n = this.playbackSpeed !== t;
+    this.playbackSpeed = t, n && (this.time = D(this.currentTime));
+  }
+  play() {
+    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver: t = $r, onPlay: n, startTime: s } = this.options;
+    this.driver || (this.driver = t((r) => this.tick(r))), n && n();
+    const i = this.driver.now();
+    this.holdTime !== null ? this.startTime = i - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = i) : this.startTime = s ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    var t;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.teardown(), this.state = "finished";
+    const { onComplete: t } = this.options;
+    t && t();
+  }
+  cancel() {
+    this.cancelTime !== null && this.tick(this.cancelTime), this.teardown(), this.updateFinishedPromise();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.resolveFinishedPromise(), this.updateFinishedPromise(), this.startTime = this.cancelTime = null, this.resolver.cancel();
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+}
+const _r = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
+  // or until we implement support for linear() easing.
+  // "background-color"
+]), Gr = 10, kr = (e, t) => {
+  let n = "";
+  const s = Math.max(Math.round(t / Gr), 2);
+  for (let i = 0; i < s; i++)
+    n += e(ft(0, s - 1, i)) + ", ";
+  return `linear(${n.substring(0, n.length - 2)})`;
+}, zr = {
+  linearEasing: void 0
+};
+function jr(e, t) {
+  const n = Ft(e);
+  return () => {
+    var s;
+    return (s = zr[t]) !== null && s !== void 0 ? s : n();
+  };
+}
+const at = /* @__PURE__ */ jr(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing");
+function ys(e) {
+  return !!(typeof e == "function" && at() || !e || typeof e == "string" && (e in Xt || at()) || ge(e) || Array.isArray(e) && e.every(ys));
+}
+const tt = ([e, t, n, s]) => `cubic-bezier(${e}, ${t}, ${n}, ${s})`, Xt = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ tt([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ tt([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ tt([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ tt([0.33, 1.53, 0.69, 0.99])
+};
+function vs(e, t) {
+  if (e)
+    return typeof e == "function" && at() ? kr(e, t) : ge(e) ? tt(e) : Array.isArray(e) ? e.map((n) => vs(n, t) || Xt.easeOut) : Xt[e];
+}
+function bs(e, t, n, { delay: s = 0, duration: i = 300, repeat: r = 0, repeatType: o = "loop", ease: a, times: l } = {}) {
+  const u = { [t]: n };
+  l && (u.offset = l);
+  const c = vs(a, i);
+  return Array.isArray(c) && (u.easing = c), e.animate(u, {
+    delay: s,
+    duration: i,
+    easing: Array.isArray(c) ? "linear" : c,
+    fill: "both",
+    iterations: r + 1,
+    direction: o === "reverse" ? "alternate" : "normal"
+  });
+}
+function Vt(e, t) {
+  e.timeline = t, e.onfinish = null;
+}
+const ws = /* @__PURE__ */ Ft(() => Object.hasOwnProperty.call(Element.prototype, "animate")), At = 10, Ur = 2e4;
+function Hr(e) {
+  return ht(e.type) || e.type === "spring" || !ys(e.ease);
+}
+function qr(e, t) {
+  const n = new we({
+    ...t,
+    keyframes: e,
+    repeat: 0,
+    delay: 0,
+    isGenerator: !0
+  });
+  let s = { done: !1, value: e[0] };
+  const i = [];
+  let r = 0;
+  for (; !s.done && r < Ur; )
+    s = n.sample(r), i.push(s.value), r += At;
+  return {
+    times: void 0,
+    keyframes: i,
+    duration: r - At,
+    ease: "linear"
+  };
+}
+const Ts = {
+  anticipate: Yn,
+  backInOut: qn,
+  circInOut: Xn
+};
+function Yr(e) {
+  return e in Ts;
+}
+class nn extends ds {
+  constructor(t) {
+    super(t);
+    const { name: n, motionValue: s, element: i, keyframes: r } = this.options;
+    this.resolver = new hs(r, (o, a) => this.onKeyframesResolved(o, a), n, s, i), this.resolver.scheduleResolve();
+  }
+  initPlayback(t, n) {
+    var s;
+    let { duration: i = 300, times: r, ease: o, type: a, motionValue: l, name: u, startTime: c } = this.options;
+    if (!(!((s = l.owner) === null || s === void 0) && s.current))
+      return !1;
+    if (typeof o == "string" && at() && Yr(o) && (o = Ts[o]), Hr(this.options)) {
+      const { onComplete: h, onUpdate: p, motionValue: m, element: w, ...b } = this.options, g = qr(t, b);
+      t = g.keyframes, t.length === 1 && (t[1] = t[0]), i = g.duration, r = g.times, o = g.ease, a = "keyframes";
+    }
+    const f = bs(l.owner.current, u, t, { ...this.options, duration: i, times: r, ease: o });
+    return f.startTime = c ?? this.calcStartTime(), this.pendingTimeline ? (Vt(f, this.pendingTimeline), this.pendingTimeline = void 0) : f.onfinish = () => {
+      const { onComplete: h } = this.options;
+      l.set(pt(t, this.options, n)), h && h(), this.cancel(), this.resolveFinishedPromise();
+    }, {
+      animation: f,
+      duration: i,
+      times: r,
+      type: a,
+      ease: o,
+      keyframes: t
+    };
+  }
+  get duration() {
+    const { resolved: t } = this;
+    if (!t)
+      return 0;
+    const { duration: n } = t;
+    return D(n);
+  }
+  get time() {
+    const { resolved: t } = this;
+    if (!t)
+      return 0;
+    const { animation: n } = t;
+    return D(n.currentTime || 0);
+  }
+  set time(t) {
+    const { resolved: n } = this;
+    if (!n)
+      return;
+    const { animation: s } = n;
+    s.currentTime = C(t);
+  }
+  get speed() {
+    const { resolved: t } = this;
+    if (!t)
+      return 1;
+    const { animation: n } = t;
+    return n.playbackRate;
+  }
+  set speed(t) {
+    const { resolved: n } = this;
+    if (!n)
+      return;
+    const { animation: s } = n;
+    s.playbackRate = t;
+  }
+  get state() {
+    const { resolved: t } = this;
+    if (!t)
+      return "idle";
+    const { animation: n } = t;
+    return n.playState;
+  }
+  get startTime() {
+    const { resolved: t } = this;
+    if (!t)
+      return null;
+    const { animation: n } = t;
+    return n.startTime;
+  }
+  /**
+   * Replace the default DocumentTimeline with another AnimationTimeline.
+   * Currently used for scroll animations.
+   */
+  attachTimeline(t) {
+    if (!this._resolved)
+      this.pendingTimeline = t;
+    else {
+      const { resolved: n } = this;
+      if (!n)
+        return N;
+      const { animation: s } = n;
+      Vt(s, t);
+    }
+    return N;
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { resolved: t } = this;
+    if (!t)
+      return;
+    const { animation: n } = t;
+    n.playState === "finished" && this.updateFinishedPromise(), n.play();
+  }
+  pause() {
+    const { resolved: t } = this;
+    if (!t)
+      return;
+    const { animation: n } = t;
+    n.pause();
+  }
+  stop() {
+    if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+      return;
+    this.resolveFinishedPromise(), this.updateFinishedPromise();
+    const { resolved: t } = this;
+    if (!t)
+      return;
+    const { animation: n, keyframes: s, duration: i, type: r, ease: o, times: a } = t;
+    if (n.playState === "idle" || n.playState === "finished")
+      return;
+    if (this.time) {
+      const { motionValue: u, onUpdate: c, onComplete: f, element: h, ...p } = this.options, m = new we({
+        ...p,
+        keyframes: s,
+        duration: i,
+        type: r,
+        ease: o,
+        times: a,
+        isGenerator: !0
+      }), w = C(this.time);
+      u.setWithVelocity(m.sample(w - At).value, m.sample(w).value, At);
+    }
+    const { onStop: l } = this.options;
+    l && l(), this.cancel();
+  }
+  complete() {
+    const { resolved: t } = this;
+    t && t.animation.finish();
+  }
+  cancel() {
+    const { resolved: t } = this;
+    t && t.animation.cancel();
+  }
+  static supports(t) {
+    const { motionValue: n, name: s, repeatDelay: i, repeatType: r, damping: o, type: a } = t;
+    return ws() && s && _r.has(s) && n && n.owner && n.owner.current instanceof HTMLElement && /**
+     * If we're outputting values to onUpdate then we can't use WAAPI as there's
+     * no way to read the value from WAAPI every frame.
+     */
+    !n.owner.getProps().onUpdate && !i && r !== "mirror" && o !== 0 && a !== "inertia";
+  }
+}
+function Xr({ when: e, delay: t, delayChildren: n, staggerChildren: s, staggerDirection: i, repeat: r, repeatType: o, repeatDelay: a, from: l, elapsed: u, ...c }) {
+  return !!Object.keys(c).length;
+}
+const Ss = (e, t, n, s = {}, i, r) => (o) => {
+  const a = ae(s, e) || {}, l = a.delay || s.delay || 0;
+  let { elapsed: u = 0 } = s;
+  u = u - C(l);
+  let c = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: t.getVelocity(),
+    ...a,
+    delay: -u,
+    onUpdate: (h) => {
+      t.set(h), a.onUpdate && a.onUpdate(h);
+    },
+    onComplete: () => {
+      o(), a.onComplete && a.onComplete();
+    },
+    name: e,
+    motionValue: t,
+    element: r ? void 0 : i
+  };
+  Xr(a) || (c = {
+    ...c,
+    ...Ni(e, c)
+  }), c.duration && (c.duration = C(c.duration)), c.repeatDelay && (c.repeatDelay = C(c.repeatDelay)), c.from !== void 0 && (c.keyframes[0] = c.from);
+  let f = !1;
+  if ((c.type === !1 || c.duration === 0 && !c.repeatDelay) && (c.duration = 0, c.delay === 0 && (f = !0)), f && !r && t.get() !== void 0) {
+    const h = pt(c.keyframes, a);
+    if (h !== void 0)
+      return M.update(() => {
+        c.onUpdate(h), c.onComplete();
+      }), new se([]);
+  }
+  return !r && nn.supports(c) ? new nn(c) : new we(c);
+}, Zr = (e) => Array.isArray(e), Qr = (e) => Zr(e) ? e[e.length - 1] || 0 : e;
+function sn(e) {
+  const t = [{}, {}];
+  return e == null || e.values.forEach((n, s) => {
+    t[0][s] = n.get(), t[1][s] = n.getVelocity();
+  }), t;
+}
+function xs(e, t, n, s) {
+  if (typeof t == "function") {
+    const [i, r] = sn(s);
+    t = t(n !== void 0 ? n : e.custom, i, r);
+  }
+  if (typeof t == "string" && (t = e.variants && e.variants[t]), typeof t == "function") {
+    const [i, r] = sn(s);
+    t = t(n !== void 0 ? n : e.custom, i, r);
+  }
+  return t;
+}
+function Jr(e, t, n) {
+  const s = e.getProps();
+  return xs(s, t, s.custom, e);
+}
+function to(e, t, n) {
+  e.hasValue(t) ? e.getValue(t).set(n) : e.addValue(t, it(n));
+}
+function eo(e, t) {
+  const n = Jr(e, t);
+  let { transitionEnd: s = {}, transition: i = {}, ...r } = n || {};
+  r = { ...r, ...s };
+  for (const o in r) {
+    const a = Qr(r[o]);
+    to(e, o, a);
+  }
+}
+const Te = (e) => e.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase(), no = "framerAppearId", so = "data-" + Te(no);
+function io(e) {
+  return e.props[so];
+}
+function ro(e) {
+  return !!(P(e) && e.add);
+}
+function oo(e, t) {
+  const n = e.getValue("willChange");
+  if (ro(n))
+    return n.add(t);
+}
+function ao({ protectedKeys: e, needsAnimating: t }, n) {
+  const s = e.hasOwnProperty(n) && t[n] !== !0;
+  return t[n] = !1, s;
+}
+function lo(e, t, { delay: n = 0, transitionOverride: s, type: i } = {}) {
+  var r;
+  let { transition: o = e.getDefaultTransition(), transitionEnd: a, ...l } = t;
+  s && (o = s);
+  const u = [], c = i && e.animationState && e.animationState.getState()[i];
+  for (const f in l) {
+    const h = e.getValue(f, (r = e.latestValues[f]) !== null && r !== void 0 ? r : null), p = l[f];
+    if (p === void 0 || c && ao(c, f))
+      continue;
+    const m = {
+      delay: n,
+      ...ae(o || {}, f)
+    };
+    let w = !1;
+    if (window.MotionHandoffAnimation) {
+      const g = io(e);
+      if (g) {
+        const y = window.MotionHandoffAnimation(g, f, M);
+        y !== null && (m.startTime = y, w = !0);
+      }
+    }
+    oo(e, f), h.start(Ss(f, h, p, e.shouldReduceMotion && U.has(f) ? { type: !1 } : m, e, w));
+    const b = h.animation;
+    b && u.push(b);
+  }
+  return a && Promise.all(u).then(() => {
+    M.update(() => {
+      a && eo(e, a);
+    });
+  }), u;
+}
+function uo(e) {
+  return e instanceof SVGElement && e.tagName !== "svg";
+}
+const co = {};
+function fo(e, { layout: t, layoutId: n }) {
+  return U.has(e) || e.startsWith("origin") || (t || n !== void 0) && (!!co[e] || e === "opacity");
+}
+function Vs(e, t, n) {
+  var s;
+  const { style: i } = e, r = {};
+  for (const o in i)
+    (P(i[o]) || t.style && P(t.style[o]) || fo(o, e) || ((s = n == null ? void 0 : n.getValue(o)) === null || s === void 0 ? void 0 : s.liveStyle) !== void 0) && (r[o] = i[o]);
+  return r;
+}
+function ho(e, t, n) {
+  const s = Vs(e, t, n);
+  for (const i in e)
+    if (P(e[i]) || P(t[i])) {
+      const r = dt.indexOf(i) !== -1 ? "attr" + i.charAt(0).toUpperCase() + i.substring(1) : i;
+      s[r] = e[i];
+    }
+  return s;
+}
+const po = typeof window < "u", Zt = { current: null }, As = { current: !1 };
+function mo() {
+  if (As.current = !0, !!po)
+    if (window.matchMedia) {
+      const e = window.matchMedia("(prefers-reduced-motion)"), t = () => Zt.current = e.matches;
+      e.addListener(t), t();
+    } else
+      Zt.current = !1;
+}
+function go(e) {
+  return e !== null && typeof e == "object" && typeof e.start == "function";
+}
+function yo(e) {
+  return typeof e == "string" || Array.isArray(e);
+}
+const vo = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], bo = ["initial", ...vo];
+function Es(e) {
+  return go(e.animate) || bo.some((t) => yo(e[t]));
+}
+function wo(e) {
+  return !!(Es(e) || e.variants);
+}
+function To(e, t, n) {
+  for (const s in t) {
+    const i = t[s], r = n[s];
+    if (P(i))
+      e.addValue(s, i), process.env.NODE_ENV === "development" && Ct(i.version === "11.11.11", `Attempting to mix Framer Motion versions ${i.version} with 11.11.11 may not work as expected.`);
+    else if (P(r))
+      e.addValue(s, it(i, { owner: e }));
+    else if (r !== i)
+      if (e.hasValue(s)) {
+        const o = e.getValue(s);
+        o.liveStyle === !0 ? o.jump(i) : o.hasAnimated || o.set(i);
+      } else {
+        const o = e.getStaticValue(s);
+        e.addValue(s, it(o !== void 0 ? o : i, { owner: e }));
+      }
+  }
+  for (const s in n)
+    t[s] === void 0 && e.removeValue(s);
+  return t;
+}
+const rn = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, Qt = {};
+for (const e in rn)
+  Qt[e] = {
+    isEnabled: (t) => rn[e].some((n) => !!t[n])
+  };
+const So = [...ss, E, Z], xo = (e) => So.find(ns(e)), on = () => ({ min: 0, max: 0 }), Se = () => ({
+  x: on(),
+  y: on()
+}), an = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class Ms {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(t, n, s) {
+    return {};
+  }
+  constructor({ parent: t, props: n, presenceContext: s, reducedMotionConfig: i, blockInitialAnimation: r, visualState: o }, a = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = fe, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const h = B.now();
+      this.renderScheduledAt < h && (this.renderScheduledAt = h, M.render(this.render, !1, !0));
+    };
+    const { latestValues: l, renderState: u } = o;
+    this.latestValues = l, this.baseTarget = { ...l }, this.initialValues = n.initial ? { ...l } : {}, this.renderState = u, this.parent = t, this.props = n, this.presenceContext = s, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = i, this.options = a, this.blockInitialAnimation = !!r, this.isControllingVariants = Es(n), this.isVariantNode = wo(n), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: c, ...f } = this.scrapeMotionValuesFromProps(n, {}, this);
+    for (const h in f) {
+      const p = f[h];
+      l[h] !== void 0 && P(p) && p.set(l[h], !1);
+    }
+  }
+  mount(t) {
+    this.current = t, L.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((n, s) => this.bindToMotionValue(s, n)), As.current || mo(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : Zt.current, process.env.NODE_ENV !== "production" && Ct(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), this.parent && this.parent.children.add(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    L.delete(this.current), this.projection && this.projection.unmount(), _(this.notifyUpdate), _(this.render), this.valueSubscriptions.forEach((t) => t()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent && this.parent.children.delete(this);
+    for (const t in this.events)
+      this.events[t].clear();
+    for (const t in this.features) {
+      const n = this.features[t];
+      n && (n.unmount(), n.isMounted = !1);
+    }
+    this.current = null;
+  }
+  bindToMotionValue(t, n) {
+    this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)();
+    const s = U.has(t), i = n.on("change", (a) => {
+      this.latestValues[t] = a, this.props.onUpdate && M.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0);
+    }), r = n.on("renderRequest", this.scheduleRender);
+    let o;
+    window.MotionCheckAppearSync && (o = window.MotionCheckAppearSync(this, t, n)), this.valueSubscriptions.set(t, () => {
+      i(), r(), o && o(), n.owner && n.stop();
+    });
+  }
+  sortNodePosition(t) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== t.type ? 0 : this.sortInstanceNodePosition(this.current, t.current);
+  }
+  updateFeatures() {
+    let t = "animation";
+    for (t in Qt) {
+      const n = Qt[t];
+      if (!n)
+        continue;
+      const { isEnabled: s, Feature: i } = n;
+      if (!this.features[t] && i && s(this.props) && (this.features[t] = new i(this)), this.features[t]) {
+        const r = this.features[t];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : Se();
+  }
+  getStaticValue(t) {
+    return this.latestValues[t];
+  }
+  setStaticValue(t, n) {
+    this.latestValues[t] = n;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(t, n) {
+    (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = n;
+    for (let s = 0; s < an.length; s++) {
+      const i = an[s];
+      this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
+      const r = "on" + i, o = t[r];
+      o && (this.propEventSubscriptions[i] = this.on(i, o));
+    }
+    this.prevMotionValues = To(this, this.scrapeMotionValuesFromProps(t, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(t) {
+    return this.props.variants ? this.props.variants[t] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(t) {
+    const n = this.getClosestVariantNode();
+    if (n)
+      return n.variantChildren && n.variantChildren.add(t), () => n.variantChildren.delete(t);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(t, n) {
+    const s = this.values.get(t);
+    n !== s && (s && this.removeValue(t), this.bindToMotionValue(t, n), this.values.set(t, n), this.latestValues[t] = n.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(t) {
+    this.values.delete(t);
+    const n = this.valueSubscriptions.get(t);
+    n && (n(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(t) {
+    return this.values.has(t);
+  }
+  getValue(t, n) {
+    if (this.props.values && this.props.values[t])
+      return this.props.values[t];
+    let s = this.values.get(t);
+    return s === void 0 && n !== void 0 && (s = it(n === null ? void 0 : n, { owner: this }), this.addValue(t, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(t, n) {
+    var s;
+    let i = this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : (s = this.getBaseTargetFromProps(this.props, t)) !== null && s !== void 0 ? s : this.readValueFromInstance(this.current, t, this.options);
+    return i != null && (typeof i == "string" && (Qn(i) || Zn(i)) ? i = parseFloat(i) : !xo(i) && Z.test(n) && (i = fs(t, n)), this.setBaseTarget(t, P(i) ? i.get() : i)), P(i) ? i.get() : i;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(t, n) {
+    this.baseTarget[t] = n;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(t) {
+    var n;
+    const { initial: s } = this.props;
+    let i;
+    if (typeof s == "string" || typeof s == "object") {
+      const o = xs(this.props, s, (n = this.presenceContext) === null || n === void 0 ? void 0 : n.custom);
+      o && (i = o[t]);
+    }
+    if (s && i !== void 0)
+      return i;
+    const r = this.getBaseTargetFromProps(this.props, t);
+    return r !== void 0 && !P(r) ? r : this.initialValues[t] !== void 0 && i === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, n) {
+    return this.events[t] || (this.events[t] = new Ln()), this.events[t].add(n);
+  }
+  notify(t, ...n) {
+    this.events[t] && this.events[t].notify(...n);
+  }
+}
+class Ps extends Ms {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = hs;
+  }
+  sortInstanceNodePosition(t, n) {
+    return t.compareDocumentPosition(n) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(t, n) {
+    return t.style ? t.style[n] : void 0;
+  }
+  removeValueFromRenderState(t, { vars: n, style: s }) {
+    delete n[t], delete s[t];
+  }
+}
+const Cs = (e, t) => t && typeof e == "number" ? t.transform(e) : e, Vo = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, Ao = dt.length;
+function Eo(e, t, n) {
+  let s = "", i = !0;
+  for (let r = 0; r < Ao; r++) {
+    const o = dt[r], a = e[o];
+    if (a === void 0)
+      continue;
+    let l = !0;
+    if (typeof a == "number" ? l = a === (o.startsWith("scale") ? 1 : 0) : l = parseFloat(a) === 0, !l || n) {
+      const u = Cs(a, pe[o]);
+      if (!l) {
+        i = !1;
+        const c = Vo[o] || o;
+        s += `${c}(${u}) `;
+      }
+      n && (t[o] = u);
+    }
+  }
+  return s = s.trim(), n ? s = n(t, i ? "" : s) : i && (s = "none"), s;
+}
+function Fs(e, t, n) {
+  const { style: s, vars: i, transformOrigin: r } = e;
+  let o = !1, a = !1;
+  for (const l in t) {
+    const u = t[l];
+    if (U.has(l)) {
+      o = !0;
+      continue;
+    } else if (ts(l)) {
+      i[l] = u;
+      continue;
+    } else {
+      const c = Cs(u, pe[l]);
+      l.startsWith("origin") ? (a = !0, r[l] = c) : s[l] = c;
+    }
+  }
+  if (t.transform || (o || n ? s.transform = Eo(t, e.transform, n) : s.transform && (s.transform = "none")), a) {
+    const { originX: l = "50%", originY: u = "50%", originZ: c = 0 } = r;
+    s.transformOrigin = `${l} ${u} ${c}`;
+  }
+}
+function ln(e, t, n) {
+  return typeof e == "string" ? e : d.transform(t + n * e);
+}
+function Mo(e, t, n) {
+  const s = ln(t, e.x, e.width), i = ln(n, e.y, e.height);
+  return `${s} ${i}`;
+}
+const Po = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, Co = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function Fo(e, t, n = 1, s = 0, i = !0) {
+  e.pathLength = 1;
+  const r = i ? Po : Co;
+  e[r.offset] = d.transform(-s);
+  const o = d.transform(t), a = d.transform(n);
+  e[r.array] = `${o} ${a}`;
+}
+function Oo(e, {
+  attrX: t,
+  attrY: n,
+  attrScale: s,
+  originX: i,
+  originY: r,
+  pathLength: o,
+  pathSpacing: a = 1,
+  pathOffset: l = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...u
+}, c, f) {
+  if (Fs(e, u, f), c) {
+    e.style.viewBox && (e.attrs.viewBox = e.style.viewBox);
+    return;
+  }
+  e.attrs = e.style, e.style = {};
+  const { attrs: h, style: p, dimensions: m } = e;
+  h.transform && (m && (p.transform = h.transform), delete h.transform), m && (i !== void 0 || r !== void 0 || p.transform) && (p.transformOrigin = Mo(m, i !== void 0 ? i : 0.5, r !== void 0 ? r : 0.5)), t !== void 0 && (h.x = t), n !== void 0 && (h.y = n), s !== void 0 && (h.scale = s), o !== void 0 && Fo(h, o, a, l, !1);
+}
+const Os = /* @__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 Ds(e, { style: t, vars: n }, s, i) {
+  Object.assign(e.style, t, i && i.getProjectionStyles(s));
+  for (const r in n)
+    e.style.setProperty(r, n[r]);
+}
+function Do(e, t, n, s) {
+  Ds(e, t, void 0, s);
+  for (const i in t.attrs)
+    e.setAttribute(Os.has(i) ? i : Te(i), t.attrs[i]);
+}
+const Ro = (e) => typeof e == "string" && e.toLowerCase() === "svg";
+class Io extends Ps {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = Se;
+  }
+  getBaseTargetFromProps(t, n) {
+    return t[n];
+  }
+  readValueFromInstance(t, n) {
+    if (U.has(n)) {
+      const s = me(n);
+      return s && s.default || 0;
+    }
+    return n = Os.has(n) ? n : Te(n), t.getAttribute(n);
+  }
+  scrapeMotionValuesFromProps(t, n, s) {
+    return ho(t, n, s);
+  }
+  build(t, n, s) {
+    Oo(t, n, this.isSVGTag, s.transformTemplate);
+  }
+  renderInstance(t, n, s, i) {
+    Do(t, n, s, i);
+  }
+  mount(t) {
+    this.isSVGTag = Ro(t.tagName), super.mount(t);
+  }
+}
+function Bo({ top: e, left: t, right: n, bottom: s }) {
+  return {
+    x: { min: t, max: n },
+    y: { min: e, max: s }
+  };
+}
+function Lo(e, t) {
+  if (!t)
+    return e;
+  const n = t({ x: e.left, y: e.top }), s = t({ x: e.right, y: e.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: s.y,
+    right: s.x
+  };
+}
+function No(e, t) {
+  return Bo(Lo(e.getBoundingClientRect(), t));
+}
+function $o(e) {
+  return window.getComputedStyle(e);
+}
+class Ko extends Ps {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = Ds;
+  }
+  readValueFromInstance(t, n) {
+    if (U.has(n)) {
+      const s = me(n);
+      return s && s.default || 0;
+    } else {
+      const s = $o(t), i = (ts(n) ? s.getPropertyValue(n) : s[n]) || 0;
+      return typeof i == "string" ? i.trim() : i;
+    }
+  }
+  measureInstanceViewportBox(t, { transformPagePoint: n }) {
+    return No(t, n);
+  }
+  build(t, n, s) {
+    Fs(t, n, s.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(t, n, s) {
+    return Vs(t, n, s);
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: t } = this.props;
+    P(t) && (this.childSubscription = t.on("change", (n) => {
+      this.current && (this.current.textContent = `${n}`);
+    }));
+  }
+}
+function Wo(e, t) {
+  return e in t;
+}
+class _o extends Ms {
+  constructor() {
+    super(...arguments), this.type = "object";
+  }
+  readValueFromInstance(t, n) {
+    if (Wo(n, t)) {
+      const s = t[n];
+      if (typeof s == "string" || typeof s == "number")
+        return s;
+    }
+  }
+  getBaseTargetFromProps() {
+  }
+  removeValueFromRenderState(t, n) {
+    delete n.output[t];
+  }
+  measureInstanceViewportBox() {
+    return Se();
+  }
+  build(t, n) {
+    Object.assign(t.output, n);
+  }
+  renderInstance(t, { output: n }) {
+    Object.assign(t, n);
+  }
+  sortInstanceNodePosition() {
+    return 0;
+  }
+}
+function Rs(e) {
+  const t = {
+    presenceContext: null,
+    props: {},
+    visualState: {
+      renderState: {
+        transform: {},
+        transformOrigin: {},
+        style: {},
+        vars: {},
+        attrs: {}
+      },
+      latestValues: {}
+    }
+  }, n = uo(e) ? new Io(t) : new Ko(t);
+  n.mount(e), L.set(e, n);
+}
+function Go(e) {
+  const t = {
+    presenceContext: null,
+    props: {},
+    visualState: {
+      renderState: {
+        output: {}
+      },
+      latestValues: {}
+    }
+  }, n = new _o(t);
+  n.mount(e), L.set(e, n);
+}
+function ko(e, t, n) {
+  const s = P(e) ? e : it(e);
+  return s.start(Ss("", s, t, n)), s.animation;
+}
+function zo(e, t) {
+  return P(e) || typeof e == "number" || typeof e == "string" && !oe(t);
+}
+function Is(e, t, n, s) {
+  const i = [];
+  if (zo(e, t))
+    i.push(ko(e, oe(t) && t.default || t, n && (n.default || n)));
+  else {
+    const r = Gn(e, t, s), o = r.length;
+    R(!!o, "No valid elements provided.");
+    for (let a = 0; a < o; a++) {
+      const l = r[a], u = l instanceof Element ? Rs : Go;
+      L.has(l) || u(l);
+      const c = L.get(l), f = { ...n };
+      "delay" in f && typeof f.delay == "function" && (f.delay = f.delay(a, o)), i.push(...lo(c, { ...t, transition: f }, {}));
+    }
+  }
+  return i;
+}
+function jo(e, t, n) {
+  const s = [];
+  return Pi(e, t, n, { spring: ie }).forEach(({ keyframes: r, transition: o }, a) => {
+    s.push(...Is(a, r, o));
+  }), s;
+}
+function Uo(e) {
+  return Array.isArray(e) && Array.isArray(e[0]);
+}
+function Ho(e) {
+  function t(n, s, i) {
+    let r = [];
+    Uo(n) ? r = jo(n, s, e) : r = Is(n, s, i, e);
+    const o = new se(r);
+    return e && e.animations.push(o), o;
+  }
+  return t;
+}
+const qo = Ho();
+function Yo(e, t, n) {
+  e.style.setProperty(`--${t}`, n);
+}
+function Xo(e, t, n) {
+  e.style[t] = n;
+}
+const Zo = /* @__PURE__ */ Ft(() => {
+  try {
+    document.createElement("div").animate({ opacity: [1] });
+  } catch {
+    return !1;
+  }
+  return !0;
+}), bt = /* @__PURE__ */ new WeakMap();
+function Qo(e, t, n) {
+  for (let s = 0; s < t.length; s++)
+    t[s] === null && (t[s] = s === 0 ? n() : t[s - 1]), typeof t[s] == "number" && Ht[e] && (t[s] = Ht[e].transform(t[s]));
+  !Zo() && t.length < 2 && t.unshift(n());
+}
+const un = "easeOut";
+function cn(e) {
+  const t = bt.get(e) || /* @__PURE__ */ new Map();
+  return bt.set(e, t), bt.get(e);
+}
+class Jo {
+  constructor(t, n, s, i) {
+    const r = n.startsWith("--");
+    this.setValue = r ? Yo : Xo, this.options = i, this.updateFinishedPromise(), R(typeof i.type != "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "framer-motion"?`);
+    const o = cn(t).get(n);
+    o && o.stop();
+    const a = () => n.startsWith("--") ? t.style.getPropertyValue(n) : window.getComputedStyle(t)[n];
+    if (Array.isArray(s) || (s = [s]), Qo(n, s, a), ht(i.type)) {
+      const u = Wn(i, 100, i.type);
+      i.ease = at() ? u.ease : un, i.duration = C(u.duration), i.type = "keyframes";
+    } else
+      i.ease = i.ease || un;
+    this.removeAnimation = () => {
+      var u;
+      return (u = bt.get(t)) === null || u === void 0 ? void 0 : u.delete(n);
+    };
+    const l = () => {
+      this.setValue(t, n, pt(s, this.options)), this.cancel(), this.resolveFinishedPromise();
+    };
+    ws() ? (this.animation = bs(t, n, s, i), i.autoplay === !1 && this.animation.pause(), this.animation.onfinish = l, this.pendingTimeline && Vt(this.animation, this.pendingTimeline), cn(t).set(n, this)) : l();
+  }
+  get duration() {
+    return D(this.options.duration || 300);
+  }
+  get time() {
+    var t;
+    return this.animation ? D(((t = this.animation) === null || t === void 0 ? void 0 : t.currentTime) || 0) : 0;
+  }
+  set time(t) {
+    this.animation && (this.animation.currentTime = C(t));
+  }
+  get speed() {
+    return this.animation ? this.animation.playbackRate : 1;
+  }
+  set speed(t) {
+    this.animation && (this.animation.playbackRate = t);
+  }
+  get state() {
+    return this.animation ? this.animation.playState : "finished";
+  }
+  get startTime() {
+    return this.animation ? this.animation.startTime : null;
+  }
+  play() {
+    this.state === "finished" && this.updateFinishedPromise(), this.animation && this.animation.play();
+  }
+  pause() {
+    this.animation && this.animation.pause();
+  }
+  stop() {
+    !this.animation || this.state === "idle" || this.state === "finished" || (this.animation.commitStyles && this.animation.commitStyles(), this.cancel());
+  }
+  complete() {
+    this.animation && this.animation.finish();
+  }
+  cancel() {
+    this.removeAnimation();
+    try {
+      this.animation && this.animation.cancel();
+    } catch {
+    }
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(t, n) {
+    return this.currentFinishedPromise.then(t, n);
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((t) => {
+      this.resolveFinishedPromise = t;
+    });
+  }
+  attachTimeline(t) {
+    return this.animation ? Vt(this.animation, t) : this.pendingTimeline = t, N;
+  }
+}
+function ta(e, t, n, s) {
+  const i = Ot(e, s), r = i.length;
+  R(!!r, "No valid element provided.");
+  const o = [];
+  for (let a = 0; a < r; a++) {
+    const l = i[a], u = { ...n };
+    typeof u.delay == "function" && (u.delay = u.delay(a, r));
+    for (const c in t) {
+      const f = t[c], h = {
+        ...ae(n, c)
+      };
+      h.duration = h.duration ? C(h.duration) : h.duration, h.delay = C(h.delay || 0), o.push(new Jo(l, c, f, h));
+    }
+  }
+  return o;
+}
+const ea = (e) => {
+  function t(n, s, i) {
+    return new se(ta(n, s, i, e));
+  }
+  return t;
+}, vl = /* @__PURE__ */ ea(), wt = /* @__PURE__ */ new WeakMap();
+let K;
+function na(e, t) {
+  if (t) {
+    const { inlineSize: n, blockSize: s } = t[0];
+    return { width: n, height: s };
+  } else return e instanceof SVGElement && "getBBox" in e ? e.getBBox() : {
+    width: e.offsetWidth,
+    height: e.offsetHeight
+  };
+}
+function sa({ target: e, contentRect: t, borderBoxSize: n }) {
+  var s;
+  (s = wt.get(e)) === null || s === void 0 || s.forEach((i) => {
+    i({
+      target: e,
+      contentSize: t,
+      get size() {
+        return na(e, n);
+      }
+    });
+  });
+}
+function ia(e) {
+  e.forEach(sa);
+}
+function ra() {
+  typeof ResizeObserver > "u" || (K = new ResizeObserver(ia));
+}
+function oa(e, t) {
+  K || ra();
+  const n = Ot(e);
+  return n.forEach((s) => {
+    let i = wt.get(s);
+    i || (i = /* @__PURE__ */ new Set(), wt.set(s, i)), i.add(t), K == null || K.observe(s);
+  }), () => {
+    n.forEach((s) => {
+      const i = wt.get(s);
+      i == null || i.delete(t), i != null && i.size || K == null || K.unobserve(s);
+    });
+  };
+}
+const Tt = /* @__PURE__ */ new Set();
+let nt;
+function aa() {
+  nt = () => {
+    const e = {
+      width: window.innerWidth,
+      height: window.innerHeight
+    }, t = {
+      target: window,
+      size: e,
+      contentSize: e
+    };
+    Tt.forEach((n) => n(t));
+  }, window.addEventListener("resize", nt);
+}
+function la(e) {
+  return Tt.add(e), nt || aa(), () => {
+    Tt.delete(e), !Tt.size && nt && (nt = void 0);
+  };
+}
+function ua(e, t) {
+  return typeof e == "function" ? la(e) : oa(e, t);
+}
+const ca = 50, fn = () => ({
+  current: 0,
+  offset: [],
+  progress: 0,
+  scrollLength: 0,
+  targetOffset: 0,
+  targetLength: 0,
+  containerLength: 0,
+  velocity: 0
+}), fa = () => ({
+  time: 0,
+  x: fn(),
+  y: fn()
+}), ha = {
+  x: {
+    length: "Width",
+    position: "Left"
+  },
+  y: {
+    length: "Height",
+    position: "Top"
+  }
+};
+function hn(e, t, n, s) {
+  const i = n[t], { length: r, position: o } = ha[t], a = i.current, l = n.time;
+  i.current = e[`scroll${o}`], i.scrollLength = e[`scroll${r}`] - e[`client${r}`], i.offset.length = 0, i.offset[0] = 0, i.offset[1] = i.scrollLength, i.progress = ft(0, i.scrollLength, i.current);
+  const u = s - l;
+  i.velocity = u > ca ? 0 : ne(i.current - a, u);
+}
+function da(e, t, n) {
+  hn(e, "x", t, n), hn(e, "y", t, n), t.time = n;
+}
+function pa(e, t) {
+  const n = { x: 0, y: 0 };
+  let s = e;
+  for (; s && s !== t; )
+    if (s instanceof HTMLElement)
+      n.x += s.offsetLeft, n.y += s.offsetTop, s = s.offsetParent;
+    else if (s.tagName === "svg") {
+      const i = s.getBoundingClientRect();
+      s = s.parentElement;
+      const r = s.getBoundingClientRect();
+      n.x += i.left - r.left, n.y += i.top - r.top;
+    } else if (s instanceof SVGGraphicsElement) {
+      const { x: i, y: r } = s.getBBox();
+      n.x += i, n.y += r;
+      let o = null, a = s.parentNode;
+      for (; !o; )
+        a.tagName === "svg" && (o = a), a = s.parentNode;
+      s = o;
+    } else
+      break;
+  return n;
+}
+const ma = {
+  Enter: [
+    [0, 1],
+    [1, 1]
+  ],
+  Exit: [
+    [0, 0],
+    [1, 0]
+  ],
+  Any: [
+    [1, 0],
+    [0, 1]
+  ],
+  All: [
+    [0, 0],
+    [1, 1]
+  ]
+}, Jt = {
+  start: 0,
+  center: 0.5,
+  end: 1
+};
+function dn(e, t, n = 0) {
+  let s = 0;
+  if (e in Jt && (e = Jt[e]), typeof e == "string") {
+    const i = parseFloat(e);
+    e.endsWith("px") ? s = i : e.endsWith("%") ? e = i / 100 : e.endsWith("vw") ? s = i / 100 * document.documentElement.clientWidth : e.endsWith("vh") ? s = i / 100 * document.documentElement.clientHeight : e = i;
+  }
+  return typeof e == "number" && (s = t * e), n + s;
+}
+const ga = [0, 0];
+function ya(e, t, n, s) {
+  let i = Array.isArray(e) ? e : ga, r = 0, o = 0;
+  return typeof e == "number" ? i = [e, e] : typeof e == "string" && (e = e.trim(), e.includes(" ") ? i = e.split(" ") : i = [e, Jt[e] ? e : "0"]), r = dn(i[0], n, s), o = dn(i[1], t), r - o;
+}
+const va = { x: 0, y: 0 };
+function ba(e) {
+  return "getBBox" in e && e.tagName !== "svg" ? e.getBBox() : { width: e.clientWidth, height: e.clientHeight };
+}
+function wa(e, t, n) {
+  const { offset: s = ma.All } = n, { target: i = e, axis: r = "y" } = n, o = r === "y" ? "height" : "width", a = i !== e ? pa(i, e) : va, l = i === e ? { width: e.scrollWidth, height: e.scrollHeight } : ba(i), u = {
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+  t[r].offset.length = 0;
+  let c = !t[r].interpolate;
+  const f = s.length;
+  for (let h = 0; h < f; h++) {
+    const p = ya(s[h], u[o], l[o], a[r]);
+    !c && p !== t[r].interpolatorOffsets[h] && (c = !0), t[r].offset[h] = p;
+  }
+  c && (t[r].interpolate = be(t[r].offset, re(s)), t[r].interpolatorOffsets = [...t[r].offset]), t[r].progress = t[r].interpolate(t[r].current);
+}
+function Ta(e, t = e, n) {
+  if (n.x.targetOffset = 0, n.y.targetOffset = 0, t !== e) {
+    let s = t;
+    for (; s && s !== e; )
+      n.x.targetOffset += s.offsetLeft, n.y.targetOffset += s.offsetTop, s = s.offsetParent;
+  }
+  n.x.targetLength = t === e ? t.scrollWidth : t.clientWidth, n.y.targetLength = t === e ? t.scrollHeight : t.clientHeight, n.x.containerLength = e.clientWidth, n.y.containerLength = e.clientHeight, process.env.NODE_ENV !== "production" && e && t && t !== e && Ct(getComputedStyle(e).position !== "static", "Please ensure that the container has a non-static position, like 'relative', 'fixed', or 'absolute' to ensure scroll offset is calculated correctly.");
+}
+function Sa(e, t, n, s = {}) {
+  return {
+    measure: () => Ta(e, s.target, n),
+    update: (i) => {
+      da(e, n, i), (s.offset || s.target) && wa(e, n, s);
+    },
+    notify: () => t(n)
+  };
+}
+const Q = /* @__PURE__ */ new WeakMap(), pn = /* @__PURE__ */ new WeakMap(), $t = /* @__PURE__ */ new WeakMap(), mn = (e) => e === document.documentElement ? window : e;
+function xe(e, { container: t = document.documentElement, ...n } = {}) {
+  let s = $t.get(t);
+  s || (s = /* @__PURE__ */ new Set(), $t.set(t, s));
+  const i = fa(), r = Sa(t, e, i, n);
+  if (s.add(r), !Q.has(t)) {
+    const a = () => {
+      for (const h of s)
+        h.measure();
+    }, l = () => {
+      for (const h of s)
+        h.update(st.timestamp);
+    }, u = () => {
+      for (const h of s)
+        h.notify();
+    }, c = () => {
+      M.read(a, !1, !0), M.read(l, !1, !0), M.update(u, !1, !0);
+    };
+    Q.set(t, c);
+    const f = mn(t);
+    window.addEventListener("resize", c, { passive: !0 }), t !== document.documentElement && pn.set(t, ua(t, c)), f.addEventListener("scroll", c, { passive: !0 });
+  }
+  const o = Q.get(t);
+  return M.read(o, !1, !0), () => {
+    var a;
+    _(o);
+    const l = $t.get(t);
+    if (!l || (l.delete(r), l.size))
+      return;
+    const u = Q.get(t);
+    Q.delete(t), u && (mn(t).removeEventListener("scroll", u), (a = pn.get(t)) === null || a === void 0 || a(), window.removeEventListener("resize", u));
+  };
+}
+function Bs(e, t) {
+  let n;
+  const s = () => {
+    const { currentTime: i } = t, o = (i === null ? 0 : i.value) / 100;
+    n !== o && e(o), n = o;
+  };
+  return M.update(s, !0), () => _(s);
+}
+function xa({ source: e, container: t, axis: n = "y" }) {
+  e && (t = e);
+  const s = { value: 0 }, i = xe((r) => {
+    s.value = r[n].progress * 100;
+  }, { container: t, axis: n });
+  return { currentTime: s, cancel: i };
+}
+const Kt = /* @__PURE__ */ new Map();
+function Ls({ source: e, container: t = document.documentElement, axis: n = "y" } = {}) {
+  e && (t = e), Kt.has(t) || Kt.set(t, {});
+  const s = Kt.get(t);
+  return s[n] || (s[n] = Nn() ? new ScrollTimeline({ source: t, axis: n }) : xa({ source: t, axis: n })), s[n];
+}
+function Va(e) {
+  return e.length === 2;
+}
+function Ns(e) {
+  return e && (e.target || e.offset);
+}
+function Aa(e, t) {
+  return Va(e) || Ns(t) ? xe((n) => {
+    e(n[t.axis].progress, n);
+  }, t) : Bs(e, Ls(t));
+}
+function Ea(e, t) {
+  if (Ns(t))
+    return e.pause(), xe((n) => {
+      e.time = e.duration * n[t.axis].progress;
+    }, t);
+  {
+    const n = Ls(t);
+    return e.attachTimeline(n, (s) => (s.pause(), Bs((i) => {
+      s.time = s.duration * i;
+    }, n)));
+  }
+}
+function bl(e, { axis: t = "y", ...n } = {}) {
+  const s = { axis: t, ...n };
+  return typeof e == "function" ? Aa(e, s) : Ea(e, s);
+}
+const Ma = {
+  some: 0,
+  all: 1
+};
+function Pa(e, t, { root: n, margin: s, amount: i = "some" } = {}) {
+  const r = Ot(e), o = /* @__PURE__ */ new WeakMap(), a = (u) => {
+    u.forEach((c) => {
+      const f = o.get(c.target);
+      if (c.isIntersecting !== !!f)
+        if (c.isIntersecting) {
+          const h = t(c);
+          typeof h == "function" ? o.set(c.target, h) : l.unobserve(c.target);
+        } else f && (f(c), o.delete(c.target));
+    });
+  }, l = new IntersectionObserver(a, {
+    root: n,
+    rootMargin: s,
+    threshold: typeof i == "number" ? i : Ma[i]
+  });
+  return r.forEach((u) => l.observe(u)), () => l.disconnect();
+}
+function wl(e, t = "end") {
+  return (n) => {
+    n = t === "end" ? Math.min(n, 0.999) : Math.max(n, 1e-3);
+    const s = n * e, i = t === "end" ? Math.floor(s) : Math.ceil(s);
+    return j(0, 1, i / e);
+  };
+}
+function Ca(e, t) {
+  if (e === "first")
+    return 0;
+  {
+    const n = t - 1;
+    return e === "last" ? n : n / 2;
+  }
+}
+function Tl(e = 0.1, { startDelay: t = 0, from: n = 0, ease: s } = {}) {
+  return (i, r) => {
+    const o = typeof n == "number" ? n : Ca(n, r), a = Math.abs(o - i);
+    let l = e * a;
+    if (s) {
+      const u = r * e;
+      l = qt(s)(l / u) * u;
+    }
+    return t + l;
+  };
+}
+const Fa = (e) => e && typeof e == "object" && e.mix, Oa = (e) => Fa(e) ? e.mix : void 0;
+function Sl(...e) {
+  const t = !Array.isArray(e[0]), n = t ? 0 : -1, s = e[0 + n], i = e[1 + n], r = e[2 + n], o = e[3 + n], a = be(i, r, {
+    mixer: Oa(r[0]),
+    ...o
+  });
+  return t ? a(s) : a;
+}
+function Da(e, t) {
+  const n = B.now(), s = ({ timestamp: i }) => {
+    const r = i - n;
+    r >= t && (_(s), e(r - t));
+  };
+  return M.read(s, !0), () => _(s);
+}
+function xl(e, t) {
+  return Da(e, C(t));
+}
+const gn = (e, t) => Math.abs(e - t);
+function Vl(e, t) {
+  const n = gn(e.x, t.x), s = gn(e.y, t.y);
+  return Math.sqrt(n ** 2 + s ** 2);
+}
+const Al = M, El = J.reduce((e, t) => (e[t] = (n) => _(n), e), {});
+function Ra(e) {
+  return typeof e == "function" ? e() : Cn(e);
+}
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+const yn = (e) => typeof e < "u";
+function Ia(e) {
+  var t;
+  const n = Ra(e);
+  return (t = n == null ? void 0 : n.$el) != null ? t : n;
+}
+function Ba() {
+  const e = Fn(), t = zs(() => {
+    var n, s;
+    return ["#text", "#comment"].includes((n = e.value) == null ? void 0 : n.$el.nodeName) ? (s = e.value) == null ? void 0 : s.$el.nextElementSibling : Ia(e);
+  });
+  return {
+    primitiveElement: e,
+    currentElement: t
+  };
+}
+function Ve(e, t) {
+  const n = typeof e == "string" && !t ? `${e}Context` : t, s = Symbol(n);
+  return [(o) => {
+    const a = js(s, o);
+    if (a || a === null)
+      return a;
+    throw new Error(
+      `Injection \`${s.toString()}\` not found. Component must be used within ${Array.isArray(e) ? `one of the following components: ${e.join(
+        ", "
+      )}` : `\`${e}\``}`
+    );
+  }, (o) => (Us(s, o), o)];
+}
+const [La, Na] = Ve("Motion"), [$a, Ml] = Ve("AnimatePresenceContext");
+function vn(e, t) {
+  if (typeof e == "object")
+    return e;
+  if (e && t)
+    return t[e];
+}
+function Ka(e, t) {
+  return typeof e != typeof t ? !0 : Array.isArray(e) && Array.isArray(t) ? !Wa(e, t) : e !== t;
+}
+function Wa(e, t) {
+  const n = t.length;
+  if (n !== e.length)
+    return !1;
+  for (let s = 0; s < n; s++)
+    if (t[s] !== e[s])
+      return !1;
+  return !0;
+}
+function _a(e, t) {
+  !e.includes(t) && e.push(t);
+}
+function Ga(e, t) {
+  const n = e.indexOf(t);
+  n !== -1 && e.splice(n, 1);
+}
+function ka(e, t) {
+  return e[t] ? { ...e, ...e[t] } : { ...e };
+}
+function bn(e) {
+  return e == null ? void 0 : e.startsWith("--");
+}
+function za() {
+}
+const ja = (e) => e;
+function Ua(e) {
+  return typeof e == "number";
+}
+const wn = {
+  syntax: "<angle>",
+  initialValue: "0deg",
+  toDefaultUnit: (e) => `${e}deg`
+}, Ha = {
+  translate: {
+    syntax: "<length-percentage>",
+    initialValue: "0px",
+    toDefaultUnit: (e) => `${e}px`
+  },
+  rotate: wn,
+  scale: {
+    syntax: "<number>",
+    initialValue: 1,
+    toDefaultUnit: ja
+  },
+  skew: wn
+}, qa = ["translate", "scale", "rotate", "skew"], Ya = ["", "X", "Y", "Z"], Ae = /* @__PURE__ */ new Map(), Et = ["x", "y", "z"];
+qa.forEach((e) => {
+  Ya.forEach((t) => {
+    Et.push(e + t), Ae.set(
+      e + t,
+      Ha[e]
+    );
+  });
+});
+const Xa = new Set(Et), Za = (e) => Xa.has(e), Tn = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ"
+};
+function Qa([e], [t]) {
+  return Et.indexOf(e) - Et.indexOf(t);
+}
+function Ja(e, [t, n]) {
+  return `${e} ${t}(${n})`;
+}
+function tl(e) {
+  return e.sort(Qa).reduce(Ja, "").trim();
+}
+const el = {
+  translate: [0, 0],
+  rotate: 0,
+  scale: 1,
+  skew: 0,
+  x: 0,
+  y: 0,
+  z: 0
+}, $s = {
+  get: (e, t) => {
+    let n = bn(t) ? e.style.getPropertyValue(t) : getComputedStyle(e)[t];
+    if (!n && n !== "0") {
+      const s = Ae.get(t);
+      s && (n = s.initialValue);
+    }
+    return n;
+  },
+  set: (e, t, n) => {
+    bn(t) ? e.style.setProperty(t, n) : e.style[t] = n;
+  }
+};
+function Wt(e) {
+  var s;
+  const t = {}, n = [];
+  for (let i in e) {
+    const r = e[i];
+    Za(i) && i in Tn && (i = Tn[i]);
+    let o = Array.isArray(r) ? r[0] : r;
+    const a = Ae.get(i);
+    a ? (o = Ua(r) ? (s = a.toDefaultUnit) == null ? void 0 : s.call(a, r) : r, n.push([i, o])) : t[i] = o;
+  }
+  return n.length && (t.transform = tl(n)), t;
+}
+function Ks(e) {
+  return e ? e.flatMap((t) => t.type === Hs ? Ks(t.children) : [t]) : [];
+}
+const nl = Pt({
+  name: "PrimitiveSlot",
+  inheritAttrs: !1,
+  setup(e, { attrs: t, slots: n }) {
+    return () => {
+      var l, u;
+      if (!n.default)
+        return null;
+      const s = Ks(n.default()), i = s.findIndex((c) => c.type !== qs);
+      if (i === -1)
+        return s;
+      const r = s[i];
+      (l = r.props) == null || delete l.ref;
+      const o = r.props ? ee(t, r.props) : t;
+      t.class && ((u = r.props) != null && u.class) && delete r.props.class;
+      const a = Ys(r, o);
+      for (const c in o)
+        c.startsWith("on") && (a.props || (a.props = {}), a.props[c] = o[c]);
+      return s.length === 1 ? a : (s[i] = a, s);
+    };
+  }
+}), sl = Pt({
+  name: "Primitive",
+  inheritAttrs: !1,
+  props: {
+    asChild: {
+      type: Boolean,
+      default: !1
+    },
+    as: {
+      type: [String, Object],
+      default: "div"
+    }
+  },
+  setup(e, { attrs: t, slots: n }) {
+    const s = e.asChild ? "template" : e.as;
+    return typeof s == "string" && ["area", "img", "input"].includes(s) ? () => Rt(s, t) : s !== "template" ? () => Rt(e.as, t, { default: n.default }) : () => Rt(nl, t, { default: n.default });
+  }
+}), il = [
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "g",
+  "defs",
+  "use",
+  "symbol",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "clipPath",
+  "mask",
+  "pattern",
+  "image",
+  "tspan",
+  "textPath"
+];
+function Sn(e) {
+  return il.includes(e);
+}
+var Ws = function() {
+};
+process.env.NODE_ENV !== "production" && (Ws = function(e, t) {
+  if (!e)
+    throw new Error(t);
+});
+class _s {
+  constructor(t) {
+    this.state = t;
+  }
+  update() {
+  }
+}
+class rl {
+  constructor(t) {
+    this.features = [], this.features = [
+      new ol(t),
+      new al(t),
+      new ll(t),
+      new ul(t)
+    ];
+  }
+  mount() {
+    this.features.forEach((t) => t.mount());
+  }
+  unmount() {
+    this.features.forEach((t) => t.unmount());
+  }
+  update() {
+    this.features.forEach((t) => t.update());
+  }
+}
+function lt(e, t, n) {
+  e.dispatchEvent(
+    new CustomEvent(t, { detail: { originalEvent: n } })
+  );
+}
+class Ee extends _s {
+  updateGestureSubscriptions() {
+    const t = this.isActive();
+    t && !this.removeGestureSubscriptions ? this.removeGestureSubscriptions = this.subscribeEvents() : !t && this.removeGestureSubscriptions && (this.removeGestureSubscriptions(), this.removeGestureSubscriptions = void 0);
+  }
+  unmount() {
+    var t;
+    (t = this.removeGestureSubscriptions) == null || t.call(this);
+  }
+}
+function xn(e, t, n) {
+  return (s) => {
+    s.pointerType && s.pointerType !== "mouse" || (n(), lt(e, t, s));
+  };
+}
+class ol extends Ee {
+  isActive() {
+    return !!this.state.getOptions().hover;
+  }
+  constructor(t) {
+    super(t), this.subscribeEvents = () => {
+      const n = this.state.getElement(), s = xn(n, "hoverstart", () => {
+        this.state.setActive("hover", !0);
+      }), i = xn(n, "hoverend", () => {
+        this.state.setActive("hover", !1);
+      });
+      return n.addEventListener("pointerenter", s), n.addEventListener("pointerleave", i), () => {
+        n.removeEventListener("pointerenter", s), n.removeEventListener("pointerleave", i);
+      };
+    };
+  }
+  mount() {
+    this.updateGestureSubscriptions();
+  }
+  update() {
+    this.updateGestureSubscriptions();
+  }
+}
+class al extends Ee {
+  isActive() {
+    return !!this.state.getOptions().press;
+  }
+  constructor(t) {
+    super(t), this.subscribeEvents = () => {
+      const n = this.state.getElement(), s = (r) => {
+        this.state.setActive("press", !1), lt(n, "pressend", r), window.removeEventListener("pointerup", s);
+      }, i = (r) => {
+        this.state.setActive("press", !0), lt(n, "pressstart", r), window.addEventListener("pointerup", s);
+      };
+      return n.addEventListener("pointerdown", i), () => {
+        n.removeEventListener("pointerdown", i), window.removeEventListener("pointerup", s);
+      };
+    };
+  }
+  mount() {
+    this.updateGestureSubscriptions();
+  }
+  update() {
+    this.updateGestureSubscriptions();
+  }
+}
+class ll extends Ee {
+  isActive() {
+    return !!this.state.getOptions().inView;
+  }
+  constructor(t) {
+    super(t), this.subscribeEvents = () => {
+      var r;
+      const n = this.state.getElement(), { once: s, ...i } = ((r = this.state.getOptions()) == null ? void 0 : r.inViewOptions) || {};
+      return Pa(n, (o) => {
+        if (this.state.setActive("inView", !0), lt(n, "viewenter", o), !s)
+          return (a) => {
+            this.state.setActive("inView", !1), lt(n, "viewleave", a);
+          };
+      }, i);
+    };
+  }
+  mount() {
+    this.updateGestureSubscriptions();
+  }
+  update() {
+    this.updateGestureSubscriptions();
+  }
+}
+class ul extends _s {
+  constructor() {
+    super(...arguments), this.handlers = {};
+  }
+  mount() {
+    const t = this.state.getElement();
+    t && (this.handlers.motionstart = (n) => {
+      var i, r;
+      const s = n.detail.target;
+      (r = (i = this.state.getOptions()).onMotionStart) == null || r.call(i, s);
+    }, this.handlers.motioncomplete = (n) => {
+      var i, r;
+      const s = n.detail.target;
+      (r = (i = this.state.getOptions()).onMotionComplete) == null || r.call(i, s);
+    }, this.handlers.hoverstart = (n) => {
+      var i, r;
+      const s = n.detail;
+      (r = (i = this.state.getOptions()).onHoverStart) == null || r.call(i, s);
+    }, this.handlers.hoverend = (n) => {
+      var i, r;
+      const s = n.detail;
+      (r = (i = this.state.getOptions()).onHoverEnd) == null || r.call(i, s);
+    }, this.handlers.pressstart = (n) => {
+      var i, r;
+      const s = n.detail;
+      (r = (i = this.state.getOptions()).onPressStart) == null || r.call(i, s);
+    }, this.handlers.pressend = (n) => {
+      var i, r;
+      const s = n.detail;
+      (r = (i = this.state.getOptions()).onPressEnd) == null || r.call(i, s);
+    }, this.handlers.viewenter = (n) => {
+      var i, r;
+      const s = n.detail.target;
+      (r = (i = this.state.getOptions()).onViewEnter) == null || r.call(i, s);
+    }, this.handlers.viewleave = (n) => {
+      var i, r;
+      const s = n.detail.target;
+      (r = (i = this.state.getOptions()).onViewLeave) == null || r.call(i, s);
+    }, Object.entries(this.handlers).forEach(([n, s]) => {
+      t.addEventListener(n, s);
+    }));
+  }
+  unmount() {
+    const t = this.state.getElement();
+    t && Object.entries(this.handlers).forEach(([n, s]) => {
+      s && (t.removeEventListener(n, s), delete this.handlers[n]);
+    });
+  }
+}
+let W;
+const Vn = (e) => e.next(), cl = (e) => e.animateUpdates();
+function fl() {
+  if (!W)
+    return;
+  const e = W.sort(dl).map(cl);
+  e.forEach(Vn), e.forEach(Vn), W = void 0;
+}
+function An(e) {
+  W ? _a(W, e) : (W = [e], requestAnimationFrame(fl));
+}
+function hl(e) {
+  W && Ga(W, e);
+}
+function dl(e, t) {
+  return e.getDepth() - t.getDepth();
+}
+function En(e, t, n) {
+  return new CustomEvent(e, { detail: { target: t, isExit: n } });
+}
+const Mn = ["initial", "animate", "inView", "hover", "press", "exit"], Mt = /* @__PURE__ */ new WeakMap();
+class pl {
+  constructor(t, n) {
+    this.element = null, this.context = {}, this.activeStates = {
+      initial: !0,
+      animate: !0
+    }, this.options = t, this.parent = n, this.depth = (n == null ? void 0 : n.depth) + 1 || 0, this.initContext();
+    const s = t.initial === !1 ? "animate" : "initial";
+    this.featureManager = new rl(this), this.initTarget(s);
+  }
+  initContext() {
+    var t;
+    for (const n of Mn)
+      this.context[n] = typeof this.options[n] == "string" ? this.options[n] : (t = this.parent) == null ? void 0 : t.context[n];
+  }
+  initTarget(t) {
+    this.baseTarget = vn(this.options[t] || this.context[t], this.options.variants) || {}, this.target = { ...this.baseTarget };
+  }
+  get initial() {
+    return yn(this.options.initial) ? this.options.initial : this.context.initial;
+  }
+  mount(t) {
+    var s;
+    Ws(
+      !!t,
+      "Animation state must be mounted with valid Element"
+    ), this.element = t, Mt.set(t, this), L.get(t) || Rs(t);
+    const n = L.get(t);
+    if (n.update(this.options, (s = this.parent) == null ? void 0 : s.context), typeof this.initial == "object")
+      for (const i in this.initial)
+        n.setStaticValue(i, this.initial[i]);
+    else if (typeof this.initial == "string" && this.options.variants)
+      for (const i in this.options.variants[this.initial])
+        n.setStaticValue(i, this.options.variants[this.initial][i]);
+    this.featureManager.mount();
+  }
+  unmount() {
+    var t;
+    Mt.delete(this.element), hl(this), (t = L.get(this.element)) == null || t.unmount(), this.featureManager.unmount();
+  }
+  update(t) {
+    this.options = t, this.featureManager.update(), An(this);
+  }
+  setActive(t, n) {
+    this.element && (this.activeStates[t] = n, An(this));
+  }
+  *animateUpdates() {
+    const t = this.target;
+    this.target = {};
+    const n = {};
+    for (const l of Mn) {
+      if (!this.activeStates[l])
+        continue;
+      const u = vn(
+        yn(this.options[l]) ? this.options[l] : this.context[l],
+        this.options.variants
+      );
+      if (!u)
+        continue;
+      const c = { ...t, ...u };
+      for (const f in c)
+        f !== "transition" && (this.target[f] = u[f], n[f] = ka(
+          u.transition ?? this.options.transition ?? {},
+          f
+        ));
+    }
+    const s = /* @__PURE__ */ new Set([
+      ...Object.keys(this.target),
+      ...Object.keys(t)
+    ]), i = [];
+    s.forEach((l) => {
+      var u;
+      this.target[l] === void 0 && (this.target[l] = this.baseTarget[l]), Ka(t[l], this.target[l]) && ((u = this.baseTarget)[l] ?? (u[l] = $s.get(this.element, l)), i.push(
+        () => qo(
+          this.element,
+          {
+            [l]: this.target[l] === "none" ? el[l] : this.target[l]
+          },
+          n[l] || {}
+        )
+      ));
+    }), yield;
+    const r = i.map((l) => l()).filter(Boolean);
+    if (!r.length)
+      return;
+    const o = this.target;
+    this.element.dispatchEvent(En("motionstart", o));
+    const a = this.activeStates.exit;
+    Promise.all(r).then(() => {
+      this.element.dispatchEvent(En("motioncomplete", {
+        ...o
+      }, a));
+    }).catch(za);
+  }
+  isMounted() {
+    return !!this.element;
+  }
+  getDepth() {
+    return this.depth;
+  }
+  getOptions() {
+    return this.options;
+  }
+  getElement() {
+    return this.element;
+  }
+  getTarget() {
+    return this.target;
+  }
+}
+const Pl = /* @__PURE__ */ Pt({
+  __name: "Motion",
+  props: /* @__PURE__ */ Xs({
+    as: {},
+    asChild: { type: Boolean },
+    style: {},
+    hover: {},
+    press: {},
+    inView: {},
+    inViewOptions: {},
+    initial: { type: [String, Object, Boolean] },
+    animate: {},
+    exit: {},
+    variants: {},
+    transition: {},
+    onMotionStart: { type: Function },
+    onMotionComplete: { type: Function },
+    onHoverStart: { type: Function },
+    onHoverEnd: { type: Function },
+    onPressStart: { type: Function },
+    onPressEnd: { type: Function },
+    onViewEnter: { type: Function },
+    onViewLeave: { type: Function }
+  }, {
+    as: "div",
+    asChild: !1,
+    initial: void 0,
+    animate: void 0,
+    hover: void 0,
+    inView: void 0
+  }),
+  setup(e) {
+    const t = e, { initial: n } = $a({ initial: Fn(void 0) }), s = La(null), i = new pl(
+      {
+        ...t
+      },
+      s
+    );
+    Na(i);
+    const { primitiveElement: r, currentElement: o } = Ba();
+    Zs(() => {
+      i.mount(o.value), i.update({
+        ...t,
+        style: { ...t.style, ...Wt(i.getTarget()) },
+        initial: n.value === !1 ? n.value : t.initial === !0 ? void 0 : t.initial
+      });
+    }), Qs(() => {
+    });
+    let a = !1;
+    Js(() => {
+      if (!a && o.value) {
+        a = !0;
+        const c = Wt(i.getTarget());
+        for (const f in c)
+          $s.set(o.value, f, c[f]);
+      }
+      i.update({
+        ...t,
+        initial: n.value === !1 ? n.value : t.initial === !0 ? void 0 : t.initial
+      });
+    });
+    function l() {
+      if (!i.isMounted() && Sn(t.as))
+        return i.getTarget();
+    }
+    function u() {
+      return Sn(t.as) || i.isMounted() ? t.style : { ...t.style, ...Wt(i.getTarget()) };
+    }
+    return (c, f) => (On(), Dn(Cn(sl), ee({
+      ref_key: "primitiveElement",
+      ref: r,
+      as: c.as,
+      "as-child": c.asChild
+    }, l(), {
+      style: u()
+    }), {
+      default: Rn(() => [
+        In(c.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["as", "as-child", "style"]));
+  }
+}), te = /* @__PURE__ */ new WeakMap();
+function Pn(e) {
+  const t = te.get(e);
+  t && e.removeEventListener("motioncomplete", t), te.delete(e);
+}
+const [Cl, ml] = Ve("AnimatePresenceContext"), Fl = /* @__PURE__ */ Pt({
+  name: "AnimatePresence",
+  inheritAttrs: !1,
+  __name: "AnimatePresence",
+  props: {
+    mode: { default: "sync" },
+    initial: { type: Boolean, default: !0 },
+    multiple: { type: Boolean, default: !1 },
+    as: {}
+  },
+  setup(e) {
+    const t = e, { initial: n } = ti(t);
+    ml({
+      initial: n
+    });
+    function s(r) {
+      const o = Mt.get(r);
+      o && (Pn(r), o.setActive("exit", !1));
+    }
+    function i(r, o) {
+      const a = Mt.get(r);
+      if (!a)
+        return o();
+      a.setActive("exit", !0), Pn(r);
+      function l(u) {
+        var c;
+        (c = u == null ? void 0 : u.detail) != null && c.isExit && o();
+      }
+      te.set(r, l), r.addEventListener("motioncomplete", l);
+    }
+    return (r, o) => (On(), Dn(ei(r.multiple ? ni : si), ee({
+      tag: r.multiple ? r.as : void 0,
+      css: !1,
+      mode: r.mode === "wait" ? "out-in" : void 0
+    }, r.$attrs, {
+      onEnter: s,
+      onLeave: i
+    }), {
+      default: Rn(() => [
+        In(r.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["tag", "mode"]));
+  }
+});
+export {
+  Fl as AnimatePresence,
+  Pl as Motion,
+  fi as MotionValue,
+  qo as animate,
+  vl as animateMini,
+  Yn as anticipate,
+  le as backIn,
+  qn as backInOut,
+  Hn as backOut,
+  _ as cancelFrame,
+  El as cancelSync,
+  ue as circIn,
+  Xn as circInOut,
+  Gi as circOut,
+  j as clamp,
+  Ho as createScopedAnimate,
+  mt as cubicBezier,
+  xl as delay,
+  gn as distance,
+  Vl as distance2D,
+  Vr as easeIn,
+  ps as easeInOut,
+  Ar as easeOut,
+  M as frame,
+  st as frameData,
+  yl as frameSteps,
+  Pa as inView,
+  Qe as inertia,
+  be as interpolate,
+  R as invariant,
+  xt as keyframes,
+  jn as mirrorEasing,
+  gs as mix,
+  it as motionValue,
+  ye as pipe,
+  ft as progress,
+  Un as reverseEasing,
+  bl as scroll,
+  xe as scrollInfo,
+  ie as spring,
+  Tl as stagger,
+  wl as steps,
+  Al as sync,
+  Sl as transform,
+  ut as warning,
+  Si as wrap
+};