@vezham/react 0.1.7 → 0.2.0-poc-env-1

package/index-D1NSj03G.mjs

@@ -0,0 +1,1382 @@
+import { c as Pt, m as Dt, a as ye, s as $, b as Rt, n as ae, e as zt, f as qe, g as et, l as Ft, h as Wt, i as Bt, j as Ht, k as A, o as K, r as ce, p as tt, v as _t, q as nt, t as st, u as ot, w as ue, x as Gt, y as kt, z as v, A as le, B as rt, C as Y, M as fe, D, E as Nt, F as pe, G as jt, H as Ut, I as Yt, J as it, K as at, L as E, N as Xt, O as ct, P as $t, Q as Kt, R as ut, V as lt, S as ft, T as Jt, U as Qt, W as Zt, X as re, Y as qt, Z as en, _ as tn, $ as dt, a0 as nn, a1 as sn, a2 as on, a3 as ve, a4 as rn, a5 as Re, a6 as an, a7 as cn, a8 as un, a9 as mt, aa as ee, ab as ln, ac as we, ad as fn, ae as dn, af as mn, ag as pn, ah as hn, ai as gn, aj as yn, ak as vn, al as wn } from "./index-DMLUAfMZ.mjs";
+import { at as Ho, am as _o, aJ as Go, aI as ko, aG as No, an as jo, ao as Uo, aA as Yo, aO as Xo, aH as $o, ba as Ko, bb as Jo, ay as Qo, aU as Zo, aV as qo, aW as er, aX as tr, az as nr, b8 as sr, aY as or, aZ as rr, a_ as ir, aB as ar, aC as cr, aw as ur, a$ as lr, aK as fr, b6 as dr, b7 as mr, d as pr, aq as hr, b0 as gr, b1 as yr, b2 as vr, b9 as wr, aE as Sr, b5 as Ar, aL as br, aP as Er, bc as Mr, aM as xr, ax as Vr, aQ as Cr, ap as Ir, b3 as Tr, aS as Or, aF as Lr, aT as Pr, aN as Dr, aD as Rr, as as zr, b4 as Fr, aR as Wr, au as Br, av as Hr, ar as _r } from "./index-DMLUAfMZ.mjs";
+import * as Sn from "react";
+import { useInsertionEffect as pt, useEffect as O, useContext as z, useState as J, useRef as P, useCallback as ht, useLayoutEffect as An, createContext as bn, forwardRef as gt } from "react";
+import { jsx as ie } from "react/jsx-runtime";
+function yt(e, t = 100, n) {
+  const s = n({ ...e, keyframes: [0, t] }), o = Math.min(Pt(s), Dt);
+  return {
+    type: "keyframes",
+    ease: (r) => s.next(o * r).value / t,
+    duration: ye(o)
+  };
+}
+class En {
+  constructor(t) {
+    this.animation = t;
+  }
+  get duration() {
+    var t, n, s;
+    const o = ((n = (t = this.animation) === null || t === void 0 ? void 0 : t.effect) === null || n === void 0 ? void 0 : n.getComputedTiming().duration) || ((s = this.options) === null || s === void 0 ? void 0 : s.duration) || 300;
+    return ye(Number(o));
+  }
+  get time() {
+    var t;
+    return this.animation ? ye(((t = this.animation) === null || t === void 0 ? void 0 : t.currentTime) || 0) : 0;
+  }
+  set time(t) {
+    this.animation && (this.animation.currentTime = $(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;
+  }
+  get finished() {
+    return this.animation ? this.animation.finished : Promise.resolve();
+  }
+  play() {
+    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());
+  }
+  flatten() {
+    var t;
+    this.animation && ((t = this.animation.effect) === null || t === void 0 || t.updateTiming({ easing: "linear" }));
+  }
+  attachTimeline(t) {
+    return this.animation && Rt(this.animation, t), ae;
+  }
+  complete() {
+    this.animation && this.animation.finish();
+  }
+  cancel() {
+    try {
+      this.animation && this.animation.cancel();
+    } catch {
+    }
+  }
+}
+const Mn = /* @__PURE__ */ zt({
+  ...qe,
+  ...Bt,
+  ...Wt,
+  ...Ft
+}, et), vt = /* @__PURE__ */ Ht(Mn), ro = {
+  renderer: et,
+  ...qe
+};
+function xn(e, t, n) {
+  pt(() => e.on(t, n), [e, t, n]);
+}
+function wt(e, t) {
+  let n;
+  const s = () => {
+    const { currentTime: o } = t, i = (o === null ? 0 : o.value) / 100;
+    n !== i && e(i), n = i;
+  };
+  return A.update(s, !0), () => K(s);
+}
+const te = /* @__PURE__ */ new WeakMap();
+let T;
+function Vn(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 Cn({ target: e, contentRect: t, borderBoxSize: n }) {
+  var s;
+  (s = te.get(e)) === null || s === void 0 || s.forEach((o) => {
+    o({
+      target: e,
+      contentSize: t,
+      get size() {
+        return Vn(e, n);
+      }
+    });
+  });
+}
+function In(e) {
+  e.forEach(Cn);
+}
+function Tn() {
+  typeof ResizeObserver > "u" || (T = new ResizeObserver(In));
+}
+function On(e, t) {
+  T || Tn();
+  const n = ce(e);
+  return n.forEach((s) => {
+    let o = te.get(s);
+    o || (o = /* @__PURE__ */ new Set(), te.set(s, o)), o.add(t), T == null || T.observe(s);
+  }), () => {
+    n.forEach((s) => {
+      const o = te.get(s);
+      o == null || o.delete(t), o != null && o.size || T == null || T.unobserve(s);
+    });
+  };
+}
+const ne = /* @__PURE__ */ new Set();
+let X;
+function Ln() {
+  X = () => {
+    const e = {
+      width: window.innerWidth,
+      height: window.innerHeight
+    }, t = {
+      target: window,
+      size: e,
+      contentSize: e
+    };
+    ne.forEach((n) => n(t));
+  }, window.addEventListener("resize", X);
+}
+function Pn(e) {
+  return ne.add(e), X || Ln(), () => {
+    ne.delete(e), !ne.size && X && (X = void 0);
+  };
+}
+function Dn(e, t) {
+  return typeof e == "function" ? Pn(e) : On(e, t);
+}
+const Rn = 50, ze = () => ({
+  current: 0,
+  offset: [],
+  progress: 0,
+  scrollLength: 0,
+  targetOffset: 0,
+  targetLength: 0,
+  containerLength: 0,
+  velocity: 0
+}), zn = () => ({
+  time: 0,
+  x: ze(),
+  y: ze()
+}), Fn = {
+  x: {
+    length: "Width",
+    position: "Left"
+  },
+  y: {
+    length: "Height",
+    position: "Top"
+  }
+};
+function Fe(e, t, n, s) {
+  const o = n[t], { length: r, position: i } = Fn[t], c = o.current, a = n.time;
+  o.current = e[`scroll${i}`], o.scrollLength = e[`scroll${r}`] - e[`client${r}`], o.offset.length = 0, o.offset[0] = 0, o.offset[1] = o.scrollLength, o.progress = tt(0, o.scrollLength, o.current);
+  const u = s - a;
+  o.velocity = u > Rn ? 0 : _t(o.current - c, u);
+}
+function Wn(e, t, n) {
+  Fe(e, "x", t, n), Fe(e, "y", t, n), t.time = n;
+}
+function Bn(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 o = s.getBoundingClientRect();
+      s = s.parentElement;
+      const r = s.getBoundingClientRect();
+      n.x += o.left - r.left, n.y += o.top - r.top;
+    } else if (s instanceof SVGGraphicsElement) {
+      const { x: o, y: r } = s.getBBox();
+      n.x += o, n.y += r;
+      let i = null, c = s.parentNode;
+      for (; !i; )
+        c.tagName === "svg" && (i = c), c = s.parentNode;
+      s = i;
+    } else
+      break;
+  return n;
+}
+const Se = {
+  start: 0,
+  center: 0.5,
+  end: 1
+};
+function We(e, t, n = 0) {
+  let s = 0;
+  if (e in Se && (e = Se[e]), typeof e == "string") {
+    const o = parseFloat(e);
+    e.endsWith("px") ? s = o : e.endsWith("%") ? e = o / 100 : e.endsWith("vw") ? s = o / 100 * document.documentElement.clientWidth : e.endsWith("vh") ? s = o / 100 * document.documentElement.clientHeight : e = o;
+  }
+  return typeof e == "number" && (s = t * e), n + s;
+}
+const Hn = [0, 0];
+function _n(e, t, n, s) {
+  let o = Array.isArray(e) ? e : Hn, r = 0, i = 0;
+  return typeof e == "number" ? o = [e, e] : typeof e == "string" && (e = e.trim(), e.includes(" ") ? o = e.split(" ") : o = [e, Se[e] ? e : "0"]), r = We(o[0], n, s), i = We(o[1], t), r - i;
+}
+const Gn = {
+  All: [
+    [0, 0],
+    [1, 1]
+  ]
+}, kn = { x: 0, y: 0 };
+function Nn(e) {
+  return "getBBox" in e && e.tagName !== "svg" ? e.getBBox() : { width: e.clientWidth, height: e.clientHeight };
+}
+function jn(e, t, n) {
+  const { offset: s = Gn.All } = n, { target: o = e, axis: r = "y" } = n, i = r === "y" ? "height" : "width", c = o !== e ? Bn(o, e) : kn, a = o === e ? { width: e.scrollWidth, height: e.scrollHeight } : Nn(o), u = {
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+  t[r].offset.length = 0;
+  let l = !t[r].interpolate;
+  const d = s.length;
+  for (let f = 0; f < d; f++) {
+    const m = _n(s[f], u[i], a[i], c[r]);
+    !l && m !== t[r].interpolatorOffsets[f] && (l = !0), t[r].offset[f] = m;
+  }
+  l && (t[r].interpolate = nt(t[r].offset, st(s), { clamp: !1 }), t[r].interpolatorOffsets = [...t[r].offset]), t[r].progress = ot(0, 1, t[r].interpolate(t[r].current));
+}
+function Un(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 && ue(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 Yn(e, t, n, s = {}) {
+  return {
+    measure: () => Un(e, s.target, n),
+    update: (o) => {
+      Wn(e, n, o), (s.offset || s.target) && jn(e, n, s);
+    },
+    notify: () => t(n)
+  };
+}
+const j = /* @__PURE__ */ new WeakMap(), Be = /* @__PURE__ */ new WeakMap(), he = /* @__PURE__ */ new WeakMap(), He = (e) => e === document.documentElement ? window : e;
+function xe(e, { container: t = document.documentElement, ...n } = {}) {
+  let s = he.get(t);
+  s || (s = /* @__PURE__ */ new Set(), he.set(t, s));
+  const o = zn(), r = Yn(t, e, o, n);
+  if (s.add(r), !j.has(t)) {
+    const c = () => {
+      for (const f of s)
+        f.measure();
+    }, a = () => {
+      for (const f of s)
+        f.update(Gt.timestamp);
+    }, u = () => {
+      for (const f of s)
+        f.notify();
+    }, l = () => {
+      A.read(c, !1, !0), A.read(a, !1, !0), A.update(u, !1, !0);
+    };
+    j.set(t, l);
+    const d = He(t);
+    window.addEventListener("resize", l, { passive: !0 }), t !== document.documentElement && Be.set(t, Dn(t, l)), d.addEventListener("scroll", l, { passive: !0 });
+  }
+  const i = j.get(t);
+  return A.read(i, !1, !0), () => {
+    var c;
+    K(i);
+    const a = he.get(t);
+    if (!a || (a.delete(r), a.size))
+      return;
+    const u = j.get(t);
+    j.delete(t), u && (He(t).removeEventListener("scroll", u), (c = Be.get(t)) === null || c === void 0 || c(), window.removeEventListener("resize", u));
+  };
+}
+function Xn({ source: e, container: t, axis: n = "y" }) {
+  e && (t = e);
+  const s = { value: 0 }, o = xe((r) => {
+    s.value = r[n].progress * 100;
+  }, { container: t, axis: n });
+  return { currentTime: s, cancel: o };
+}
+const ge = /* @__PURE__ */ new Map();
+function St({ source: e, container: t = document.documentElement, axis: n = "y" } = {}) {
+  e && (t = e), ge.has(t) || ge.set(t, {});
+  const s = ge.get(t);
+  return s[n] || (s[n] = kt() ? new ScrollTimeline({ source: t, axis: n }) : Xn({ source: t, axis: n })), s[n];
+}
+function $n(e) {
+  return e.length === 2;
+}
+function At(e) {
+  return e && (e.target || e.offset);
+}
+function Kn(e, t) {
+  return $n(e) || At(t) ? xe((n) => {
+    e(n[t.axis].progress, n);
+  }, t) : wt(e, St(t));
+}
+function Jn(e, t) {
+  if (e.flatten(), At(t))
+    return e.pause(), xe((n) => {
+      e.time = e.duration * n[t.axis].progress;
+    }, t);
+  {
+    const n = St(t);
+    return e.attachTimeline ? e.attachTimeline(n, (s) => (s.pause(), wt((o) => {
+      s.time = s.duration * o;
+    }, n))) : ae;
+  }
+}
+function Qn(e, { axis: t = "y", ...n } = {}) {
+  const s = { axis: t, ...n };
+  return typeof e == "function" ? Kn(e, s) : Jn(e, s);
+}
+function _e(e, t) {
+  rt(!!(!t || t.current), `You have defined a ${e} options but the provided ref is not yet hydrated, probably because it's defined higher up the tree. Try calling useScroll() in the same component as the ref, or setting its \`layoutEffect: false\` option.`);
+}
+const Zn = () => ({
+  scrollX: Y(0),
+  scrollY: Y(0),
+  scrollXProgress: Y(0),
+  scrollYProgress: Y(0)
+});
+function bt({ container: e, target: t, layoutEffect: n = !0, ...s } = {}) {
+  const o = v(Zn);
+  return (n ? le : O)(() => (_e("target", t), _e("container", e), Qn((i, { x: c, y: a }) => {
+    o.scrollX.set(c.current), o.scrollXProgress.set(c.progress), o.scrollY.set(a.current), o.scrollYProgress.set(a.progress);
+  }, {
+    ...s,
+    container: (e == null ? void 0 : e.current) || void 0,
+    target: (t == null ? void 0 : t.current) || void 0
+  })), [e, t, JSON.stringify(s.offset)]), o;
+}
+function io(e) {
+  return process.env.NODE_ENV === "development" && ue(!1, "useElementScroll is deprecated. Convert to useScroll({ container: ref })."), bt({ container: e });
+}
+function ao() {
+  return process.env.NODE_ENV !== "production" && ue(!1, "useViewportScroll is deprecated. Convert to useScroll()."), bt();
+}
+function R(e) {
+  const t = v(() => Y(e)), { isStatic: n } = z(fe);
+  if (n) {
+    const [, s] = J(e);
+    O(() => t.on("change", s), []);
+  }
+  return t;
+}
+function Ve(e, t) {
+  const n = R(t()), s = () => n.set(t());
+  return s(), le(() => {
+    const o = () => A.preRender(s, !1, !0), r = e.map((i) => i.on("change", o));
+    return () => {
+      r.forEach((i) => i()), K(s);
+    };
+  }), n;
+}
+function co(e, ...t) {
+  const n = e.length;
+  function s() {
+    let o = "";
+    for (let r = 0; r < n; r++) {
+      o += e[r];
+      const i = t[r];
+      i && (o += D(i) ? i.get() : i);
+    }
+    return o;
+  }
+  return Ve(t.filter(D), s);
+}
+function uo(e, t = {}) {
+  const { isStatic: n } = z(fe), s = P(null), o = v(() => D(e) ? e.get() : e), r = v(() => typeof o == "string" ? o.replace(/[\d.-]/g, "") : void 0), i = R(o), c = P(o), a = P(ae), u = () => {
+    l(), s.current = Nt({
+      keyframes: [ke(i.get()), ke(c.current)],
+      velocity: i.getVelocity(),
+      type: "spring",
+      restDelta: 1e-3,
+      restSpeed: 0.01,
+      ...t,
+      onUpdate: a.current
+    });
+  }, l = () => {
+    s.current && s.current.stop();
+  };
+  return pt(() => i.attach((d, f) => n ? f(d) : (c.current = d, a.current = (m) => f(Ge(m, r)), A.postRender(u), i.get()), l), [JSON.stringify(t)]), le(() => {
+    if (D(e))
+      return e.on("change", (d) => i.set(Ge(d, r)));
+  }, [i, r]), i;
+}
+function Ge(e, t) {
+  return t ? e + t : e;
+}
+function ke(e) {
+  return typeof e == "number" ? e : parseFloat(e);
+}
+function qn(e) {
+  const t = P(0), { isStatic: n } = z(fe);
+  O(() => {
+    if (n)
+      return;
+    const s = ({ timestamp: o, delta: r }) => {
+      t.current || (t.current = o), e(o - t.current, r);
+    };
+    return A.update(s, !0), () => K(s);
+  }, [e]);
+}
+function lo() {
+  const e = R(0);
+  return qn((t) => e.set(t)), e;
+}
+const es = (e) => e && typeof e == "object" && e.mix, ts = (e) => es(e) ? e.mix : void 0;
+function ns(...e) {
+  const t = !Array.isArray(e[0]), n = t ? 0 : -1, s = e[0 + n], o = e[1 + n], r = e[2 + n], i = e[3 + n], c = nt(o, r, {
+    mixer: ts(r[0]),
+    ...i
+  });
+  return t ? c(s) : c;
+}
+function ss(e) {
+  pe.current = [], e();
+  const t = Ve(pe.current, e);
+  return pe.current = void 0, t;
+}
+function Ae(e, t, n, s) {
+  if (typeof e == "function")
+    return ss(e);
+  const o = typeof t == "function" ? t : ns(t, n, s);
+  return Array.isArray(e) ? Ne(e, o) : Ne([e], ([r]) => o(r));
+}
+function Ne(e, t) {
+  const n = v(() => []);
+  return Ve(e, () => {
+    n.length = 0;
+    const s = e.length;
+    for (let o = 0; o < s; o++)
+      n[o] = e[o].get();
+    return t(n);
+  });
+}
+function fo(e) {
+  const t = R(e.getVelocity()), n = () => {
+    const s = e.getVelocity();
+    t.set(s), s && A.update(n);
+  };
+  return xn(e, "change", () => {
+    A.update(n, !1, !0);
+  }), t;
+}
+function os() {
+  !jt.current && Ut();
+  const [e] = J(Yt.current);
+  return process.env.NODE_ENV !== "production" && ue(e !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), e;
+}
+function mo() {
+  const e = os(), { reducedMotion: t } = z(fe);
+  return t === "never" ? !1 : t === "always" ? !0 : e;
+}
+function rs(e) {
+  e.values.forEach((t) => t.stop());
+}
+function be(e, t) {
+  [...t].reverse().forEach((s) => {
+    const o = e.getVariant(s);
+    o && at(e, o), e.variantChildren && e.variantChildren.forEach((r) => {
+      be(r, t);
+    });
+  });
+}
+function is(e, t) {
+  if (Array.isArray(t))
+    return be(e, t);
+  if (typeof t == "string")
+    return be(e, [t]);
+  at(e, t);
+}
+function as() {
+  let e = !1;
+  const t = /* @__PURE__ */ new Set(), n = {
+    subscribe(s) {
+      return t.add(s), () => void t.delete(s);
+    },
+    start(s, o) {
+      E(e, "controls.start() should only be called after a component has mounted. Consider calling within a useEffect hook.");
+      const r = [];
+      return t.forEach((i) => {
+        r.push(it(i, s, {
+          transitionOverride: o
+        }));
+      }), Promise.all(r);
+    },
+    set(s) {
+      return E(e, "controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook."), t.forEach((o) => {
+        is(o, s);
+      });
+    },
+    stop() {
+      t.forEach((s) => {
+        rs(s);
+      });
+    },
+    mount() {
+      return e = !0, () => {
+        e = !1, n.stop();
+      };
+    }
+  };
+  return n;
+}
+function Et(e) {
+  return O(() => () => e(), []);
+}
+const Mt = (e, t, n) => {
+  const s = t - e;
+  return ((n - e) % s + s) % s + e;
+};
+function xt(e, t) {
+  return Xt(e) ? e[Mt(0, e.length, t)] : e;
+}
+function Ce(e) {
+  return typeof e == "object" && !Array.isArray(e);
+}
+function Vt(e, t, n, s) {
+  return typeof e == "string" && Ce(t) ? ce(e, n, s) : e instanceof NodeList ? Array.from(e) : Array.isArray(e) ? e : [e];
+}
+function cs(e, t, n) {
+  return e * (t + 1);
+}
+function je(e, t, n, s) {
+  var o;
+  return typeof t == "number" ? t : t.startsWith("-") || t.startsWith("+") ? Math.max(0, e + parseFloat(t)) : t === "<" ? n : (o = s.get(t)) !== null && o !== void 0 ? o : e;
+}
+function us(e, t, n) {
+  for (let s = 0; s < e.length; s++) {
+    const o = e[s];
+    o.at > t && o.at < n && ($t(e, o), s--);
+  }
+}
+function ls(e, t, n, s, o, r) {
+  us(e, o, r);
+  for (let i = 0; i < t.length; i++)
+    e.push({
+      value: t[i],
+      at: ct(o, r, s[i]),
+      easing: xt(n, i)
+    });
+}
+function fs(e, t) {
+  for (let n = 0; n < e.length; n++)
+    e[n] = e[n] / (t + 1);
+}
+function ds(e, t) {
+  return e.at === t.at ? e.value === null ? 1 : t.value === null ? -1 : 0 : e.at - t.at;
+}
+const ms = "easeInOut", ps = 20;
+function hs(e, { defaultTransition: t = {}, ...n } = {}, s, o) {
+  const r = t.duration || 0.3, i = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), a = {}, u = /* @__PURE__ */ new Map();
+  let l = 0, d = 0, f = 0;
+  for (let m = 0; m < e.length; m++) {
+    const p = e[m];
+    if (typeof p == "string") {
+      u.set(p, d);
+      continue;
+    } else if (!Array.isArray(p)) {
+      u.set(p.name, je(d, p.at, l, u));
+      continue;
+    }
+    let [h, g, y = {}] = p;
+    y.at !== void 0 && (d = je(d, y.at, l, u));
+    let w = 0;
+    const F = (M, x, C, B = 0, H = 0) => {
+      const S = gs(M), { delay: de = 0, times: V = st(S), type: me = "keyframes", repeat: _, repeatType: eo, repeatDelay: to = 0, ...Lt } = x;
+      let { ease: I = t.ease || "easeOut", duration: b } = x;
+      const Ie = typeof de == "function" ? de(B, H) : de, Te = S.length, Oe = ut(me) ? me : o == null ? void 0 : o[me];
+      if (Te <= 2 && Oe) {
+        let G = 100;
+        if (Te === 2 && ws(S)) {
+          const k = S[1] - S[0];
+          G = Math.abs(k);
+        }
+        const Q = { ...Lt };
+        b !== void 0 && (Q.duration = $(b));
+        const Z = yt(Q, G, Oe);
+        I = Z.ease, b = Z.duration;
+      }
+      b ?? (b = r);
+      const Le = d + Ie;
+      V.length === 1 && V[0] === 0 && (V[1] = 1);
+      const Pe = V.length - S.length;
+      if (Pe > 0 && Kt(V, Pe), S.length === 1 && S.unshift(null), _) {
+        E(_ < ps, "Repeat count too high, must be less than 20"), b = cs(b, _);
+        const G = [...S], Q = [...V];
+        I = Array.isArray(I) ? [...I] : [I];
+        const Z = [...I];
+        for (let k = 0; k < _; k++) {
+          S.push(...G);
+          for (let N = 0; N < G.length; N++)
+            V.push(Q[N] + (k + 1)), I.push(N === 0 ? "linear" : xt(Z, N - 1));
+        }
+        fs(V, _);
+      }
+      const De = Le + b;
+      ls(C, S, I, V, Le, De), w = Math.max(Ie + b, w), f = Math.max(De, f);
+    };
+    if (D(h)) {
+      const M = Ue(h, c);
+      F(g, y, Ye("default", M));
+    } else {
+      const M = Vt(h, g, s, a), x = M.length;
+      for (let C = 0; C < x; C++) {
+        g = g, y = y;
+        const B = M[C], H = Ue(B, c);
+        for (const S in g)
+          F(g[S], ys(y, S), Ye(S, H), C, x);
+      }
+    }
+    l = d, d += w;
+  }
+  return c.forEach((m, p) => {
+    for (const h in m) {
+      const g = m[h];
+      g.sort(ds);
+      const y = [], w = [], F = [];
+      for (let x = 0; x < g.length; x++) {
+        const { at: C, value: B, easing: H } = g[x];
+        y.push(B), w.push(tt(0, f, C)), F.push(H || "easeOut");
+      }
+      w[0] !== 0 && (w.unshift(0), y.unshift(y[0]), F.unshift(ms)), w[w.length - 1] !== 1 && (w.push(1), y.push(null)), i.has(p) || i.set(p, {
+        keyframes: {},
+        transition: {}
+      });
+      const M = i.get(p);
+      M.keyframes[h] = y, M.transition[h] = {
+        ...t,
+        duration: f,
+        ease: F,
+        times: w,
+        ...n
+      };
+    }
+  }), i;
+}
+function Ue(e, t) {
+  return !t.has(e) && t.set(e, {}), t.get(e);
+}
+function Ye(e, t) {
+  return t[e] || (t[e] = []), t[e];
+}
+function gs(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function ys(e, t) {
+  return e && e[t] ? {
+    ...e,
+    ...e[t]
+  } : { ...e };
+}
+const vs = (e) => typeof e == "number", ws = (e) => e.every(vs);
+function Ss(e, t) {
+  return e in t;
+}
+class As extends lt {
+  constructor() {
+    super(...arguments), this.type = "object";
+  }
+  readValueFromInstance(t, n) {
+    if (Ss(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 ft();
+  }
+  build(t, n) {
+    Object.assign(t.output, n);
+  }
+  renderInstance(t, { output: n }) {
+    Object.assign(t, n);
+  }
+  sortInstanceNodePosition() {
+    return 0;
+  }
+}
+function bs(e) {
+  const t = {
+    presenceContext: null,
+    props: {},
+    visualState: {
+      renderState: {
+        transform: {},
+        transformOrigin: {},
+        style: {},
+        vars: {},
+        attrs: {}
+      },
+      latestValues: {}
+    }
+  }, n = Jt(e) ? new Qt(t) : new Zt(t);
+  n.mount(e), re.set(e, n);
+}
+function Es(e) {
+  const t = {
+    presenceContext: null,
+    props: {},
+    visualState: {
+      renderState: {
+        output: {}
+      },
+      latestValues: {}
+    }
+  }, n = new As(t);
+  n.mount(e), re.set(e, n);
+}
+function Ms(e, t) {
+  return D(e) || typeof e == "number" || typeof e == "string" && !Ce(t);
+}
+function Ct(e, t, n, s) {
+  const o = [];
+  if (Ms(e, t))
+    o.push(qt(e, Ce(t) && t.default || t, n && (n.default || n)));
+  else {
+    const r = Vt(e, t, s), i = r.length;
+    E(!!i, "No valid elements provided.");
+    for (let c = 0; c < i; c++) {
+      const a = r[c], u = a instanceof Element ? bs : Es;
+      re.has(a) || u(a);
+      const l = re.get(a), d = { ...n };
+      "delay" in d && typeof d.delay == "function" && (d.delay = d.delay(c, i)), o.push(...en(l, { ...t, transition: d }, {}));
+    }
+  }
+  return o;
+}
+function xs(e, t, n) {
+  const s = [];
+  return hs(e, t, n, { spring: tn }).forEach(({ keyframes: r, transition: i }, c) => {
+    s.push(...Ct(c, r, i));
+  }), s;
+}
+function Vs(e) {
+  return Array.isArray(e) && e.some(Array.isArray);
+}
+function It(e) {
+  function t(n, s, o) {
+    let r = [];
+    Vs(n) ? r = xs(n, s, e) : r = Ct(n, s, o, e);
+    const i = new dt(r);
+    return e && e.animations.push(i), i;
+  }
+  return t;
+}
+const po = It();
+function ho() {
+  const e = v(() => ({
+    current: null,
+    // Will be hydrated by React
+    animations: []
+  })), t = v(() => It(e));
+  return Et(() => {
+    e.animations.forEach((n) => n.stop());
+  }), [e, t];
+}
+function Cs(e, t, n) {
+  e.style.setProperty(t, n);
+}
+function Is(e, t, n) {
+  e.style[t] = n;
+}
+const Ts = /* @__PURE__ */ nn(() => {
+  try {
+    document.createElement("div").animate({ opacity: [1] });
+  } catch {
+    return !1;
+  }
+  return !0;
+}), se = /* @__PURE__ */ new WeakMap();
+function Os(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" && Re[e] && (t[s] = Re[e].transform(t[s]));
+  !Ts() && t.length < 2 && t.unshift(n());
+}
+const Xe = "easeOut";
+function $e(e) {
+  const t = se.get(e) || /* @__PURE__ */ new Map();
+  return se.set(e, t), se.get(e);
+}
+class Ls extends En {
+  constructor(t, n, s, o) {
+    const r = n.startsWith("--");
+    E(typeof o.type != "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "framer-motion"?`);
+    const i = $e(t).get(n);
+    i && i.stop();
+    const c = () => n.startsWith("--") ? t.style.getPropertyValue(n) : window.getComputedStyle(t)[n];
+    if (Array.isArray(s) || (s = [s]), Os(n, s, c), ut(o.type)) {
+      const l = yt(o, 100, o.type);
+      o.ease = sn() ? l.ease : Xe, o.duration = $(l.duration), o.type = "keyframes";
+    } else
+      o.ease = o.ease || Xe;
+    const a = () => {
+      this.setValue(t, n, rn(s, o)), this.cancel(), this.resolveFinishedPromise();
+    }, u = () => {
+      this.setValue = r ? Cs : Is, this.options = o, this.updateFinishedPromise(), this.removeAnimation = () => {
+        const l = se.get(t);
+        l && l.delete(n);
+      };
+    };
+    on() ? (super(ve(t, n, s, o)), u(), o.autoplay === !1 && this.animation.pause(), this.animation.onfinish = a, $e(t).set(n, this)) : (super(), u(), a());
+  }
+  /**
+   * 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;
+    });
+  }
+  play() {
+    this.state === "finished" && this.updateFinishedPromise(), super.play();
+  }
+  cancel() {
+    this.removeAnimation(), super.cancel();
+  }
+}
+function Ps(e, t, n, s) {
+  const o = ce(e, s), r = o.length;
+  E(!!r, "No valid element provided.");
+  const i = [];
+  for (let c = 0; c < r; c++) {
+    const a = o[c], u = { ...n };
+    typeof u.delay == "function" && (u.delay = u.delay(c, r));
+    for (const l in t) {
+      const d = t[l], f = {
+        ...an(u, l)
+      };
+      f.duration = f.duration ? $(f.duration) : f.duration, f.delay = $(f.delay || 0), i.push(new Ls(a, l, d, f));
+    }
+  }
+  return i;
+}
+const Tt = (e) => {
+  function t(n, s, o) {
+    return new dt(Ps(n, s, o, e));
+  }
+  return t;
+}, go = /* @__PURE__ */ Tt();
+function yo() {
+  const e = v(() => ({
+    current: null,
+    // Will be hydrated by React
+    animations: []
+  })), t = v(() => Tt(e));
+  return Et(() => {
+    e.animations.forEach((n) => n.stop());
+  }), [e, t];
+}
+function Ds() {
+  const e = v(as);
+  return le(e.mount, []), e;
+}
+const vo = Ds;
+function wo() {
+  const e = z(cn);
+  return e ? e.custom : void 0;
+}
+function So(e, t, n, s) {
+  O(() => {
+    const o = e.current;
+    if (n && o)
+      return un(o, t, n, s);
+  }, [e, t, n, s]);
+}
+class Rs {
+  constructor() {
+    this.componentControls = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.
+   *
+   * @internal
+   */
+  subscribe(t) {
+    return this.componentControls.add(t), () => this.componentControls.delete(t);
+  }
+  /**
+   * Start a drag gesture on every `motion` component that has this set of drag controls
+   * passed into it via the `dragControls` prop.
+   *
+   * ```jsx
+   * dragControls.start(e, {
+   *   snapToCursor: true
+   * })
+   * ```
+   *
+   * @param event - PointerEvent
+   * @param options - Options
+   *
+   * @public
+   */
+  start(t, n) {
+    this.componentControls.forEach((s) => {
+      s.start(t.nativeEvent || t, n);
+    });
+  }
+}
+const zs = () => new Rs();
+function Ao() {
+  return v(zs);
+}
+function Fs(e) {
+  return e !== null && typeof e == "object" && mt in e;
+}
+function bo(e) {
+  if (Fs(e))
+    return e[mt];
+}
+function Ws() {
+  return Bs;
+}
+function Bs(e) {
+  ee.current && (ee.current.isUpdating = !1, ee.current.blockUpdate(), e && e());
+}
+function Eo() {
+  return ht(() => {
+    const t = ee.current;
+    t && t.resetTree();
+  }, []);
+}
+function Mo(...e) {
+  const t = P(0), [n, s] = J(e[t.current]), o = ht(
+    (r) => {
+      t.current = typeof r != "number" ? Mt(0, e.length, t.current + 1) : r, s(e[t.current]);
+    },
+    // The array will change on each call, but by putting items.length at
+    // the front of this array, we guarantee the dependency comparison will match up
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e.length, ...e]
+  );
+  return [n, o];
+}
+const Hs = {
+  some: 0,
+  all: 1
+};
+function _s(e, t, { root: n, margin: s, amount: o = "some" } = {}) {
+  const r = ce(e), i = /* @__PURE__ */ new WeakMap(), c = (u) => {
+    u.forEach((l) => {
+      const d = i.get(l.target);
+      if (l.isIntersecting !== !!d)
+        if (l.isIntersecting) {
+          const f = t(l.target, l);
+          typeof f == "function" ? i.set(l.target, f) : a.unobserve(l.target);
+        } else typeof d == "function" && (d(l), i.delete(l.target));
+    });
+  }, a = new IntersectionObserver(c, {
+    root: n,
+    rootMargin: s,
+    threshold: typeof o == "number" ? o : Hs[o]
+  });
+  return r.forEach((u) => a.observe(u)), () => a.disconnect();
+}
+function xo(e, { root: t, margin: n, amount: s, once: o = !1, initial: r = !1 } = {}) {
+  const [i, c] = J(r);
+  return O(() => {
+    if (!e.current || o && i)
+      return;
+    const a = () => (c(!0), o ? void 0 : () => c(!1)), u = {
+      root: t && t.current || void 0,
+      margin: n,
+      amount: s
+    };
+    return _s(e.current, a, u);
+  }, [t, e, n, o, s]), i;
+}
+function Vo() {
+  const [e, t] = ln(), n = Ws(), s = P(-1);
+  return O(() => {
+    A.postRender(() => A.postRender(() => {
+      t === s.current && (we.current = !1);
+    }));
+  }, [t]), (o) => {
+    n(() => {
+      we.current = !0, e(), o(), s.current = t + 1;
+    });
+  };
+}
+function Co() {
+  we.current = !1;
+}
+const oe = (e, t) => {
+  const n = fn.has(t) ? "transform" : t;
+  return `${e}: ${n}`;
+}, L = /* @__PURE__ */ new Map(), U = /* @__PURE__ */ new Map();
+function Ke(e, t, n) {
+  var s;
+  const o = oe(e, t), r = L.get(o);
+  if (!r)
+    return null;
+  const { animation: i, startTime: c } = r;
+  function a() {
+    var u;
+    (u = window.MotionCancelOptimisedAnimation) === null || u === void 0 || u.call(window, e, t, n);
+  }
+  return i.onfinish = a, c === null || !((s = window.MotionHandoffIsComplete) === null || s === void 0) && s.call(window, e) ? (a(), null) : c;
+}
+let q, W;
+const Ee = /* @__PURE__ */ new Set();
+function Gs() {
+  Ee.forEach((e) => {
+    e.animation.play(), e.animation.startTime = e.startTime;
+  }), Ee.clear();
+}
+function Io(e, t, n, s, o) {
+  if (window.MotionIsMounted)
+    return;
+  const r = e.dataset[dn];
+  if (!r)
+    return;
+  window.MotionHandoffAnimation = Ke;
+  const i = oe(r, t);
+  W || (W = ve(
+    e,
+    t,
+    [n[0], n[0]],
+    /**
+     * 10 secs is basically just a super-safe duration to give Chrome
+     * long enough to get the animation ready.
+     */
+    { duration: 1e4, ease: "linear" }
+  ), L.set(i, {
+    animation: W,
+    startTime: null
+  }), window.MotionHandoffAnimation = Ke, window.MotionHasOptimisedAnimation = (a, u) => {
+    if (!a)
+      return !1;
+    if (!u)
+      return U.has(a);
+    const l = oe(a, u);
+    return !!L.get(l);
+  }, window.MotionHandoffMarkAsComplete = (a) => {
+    U.has(a) && U.set(a, !0);
+  }, window.MotionHandoffIsComplete = (a) => U.get(a) === !0, window.MotionCancelOptimisedAnimation = (a, u, l, d) => {
+    const f = oe(a, u), m = L.get(f);
+    m && (l && d === void 0 ? l.postRender(() => {
+      l.postRender(() => {
+        m.animation.cancel();
+      });
+    }) : m.animation.cancel(), l && d ? (Ee.add(m), l.render(Gs)) : (L.delete(f), L.size || (window.MotionCancelOptimisedAnimation = void 0)));
+  }, window.MotionCheckAppearSync = (a, u, l) => {
+    var d, f;
+    const m = mn(a);
+    if (!m)
+      return;
+    const p = (d = window.MotionHasOptimisedAnimation) === null || d === void 0 ? void 0 : d.call(window, m, u), h = (f = a.props.values) === null || f === void 0 ? void 0 : f[u];
+    if (!p || !h)
+      return;
+    const g = l.on("change", (y) => {
+      var w;
+      h.get() !== y && ((w = window.MotionCancelOptimisedAnimation) === null || w === void 0 || w.call(window, m, u), g());
+    });
+    return g;
+  });
+  const c = () => {
+    W.cancel();
+    const a = ve(e, t, n, s);
+    q === void 0 && (q = performance.now()), a.startTime = q, L.set(i, {
+      animation: a,
+      startTime: q
+    }), o && o(a);
+  };
+  U.set(r, !1), W.ready ? W.ready.then(c).catch(ae) : c();
+}
+const Me = () => ({});
+class ks extends lt {
+  constructor() {
+    super(...arguments), this.measureInstanceViewportBox = ft;
+  }
+  build() {
+  }
+  resetTransform() {
+  }
+  restoreTransform() {
+  }
+  removeValueFromRenderState() {
+  }
+  renderInstance() {
+  }
+  scrapeMotionValuesFromProps() {
+    return Me();
+  }
+  getBaseTargetFromProps() {
+  }
+  readValueFromInstance(t, n, s) {
+    return s.initialState[n] || 0;
+  }
+  sortInstanceNodePosition() {
+    return 0;
+  }
+}
+const Ns = pn({
+  scrapeMotionValuesFromProps: Me,
+  createRenderState: Me
+});
+function To(e) {
+  const [t, n] = J(e), s = Ns({}, !1), o = v(() => new ks({
+    props: {
+      onUpdate: (i) => {
+        n({ ...i });
+      }
+    },
+    visualState: s,
+    presenceContext: null
+  }, { initialState: e }));
+  An(() => (o.mount({}), () => o.unmount()), [o]);
+  const r = v(() => (i) => it(o, i));
+  return [t, r];
+}
+let js = 0;
+const Oo = ({ children: e }) => (Sn.useEffect(() => {
+  E(!1, "AnimateSharedLayout is deprecated: https://www.framer.com/docs/guide-upgrade/##shared-layout-animations");
+}, []), ie(hn, { id: v(() => `asl-${js++}`), children: e })), Us = 1e5, Je = (e) => e > 1e-3 ? 1 / e : Us;
+let Qe = !1;
+function Lo(e) {
+  let t = R(1), n = R(1);
+  const { visualElement: s } = z(gn);
+  E(!!(e || s), "If no scale values are provided, useInvertedScale must be used within a child of another motion component."), rt(Qe, "useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead."), Qe = !0, e ? (t = e.scaleX || t, n = e.scaleY || n) : s && (t = s.getValue("scaleX", 1), n = s.getValue("scaleY", 1));
+  const o = Ae(t, Je), r = Ae(n, Je);
+  return { scaleX: o, scaleY: r };
+}
+const Ot = bn(null);
+function Ys(e, t, n, s) {
+  if (!s)
+    return e;
+  const o = e.findIndex((l) => l.value === t);
+  if (o === -1)
+    return e;
+  const r = s > 0 ? 1 : -1, i = e[o + r];
+  if (!i)
+    return e;
+  const c = e[o], a = i.layout, u = ct(a.min, a.max, 0.5);
+  return r === 1 && c.layout.max + n > u || r === -1 && c.layout.min + n < u ? yn(e, o, o + r) : e;
+}
+function Xs({ children: e, as: t = "ul", axis: n = "y", onReorder: s, values: o, ...r }, i) {
+  const c = v(() => vt[t]), a = [], u = P(!1);
+  E(!!o, "Reorder.Group must be provided a values prop");
+  const l = {
+    axis: n,
+    registerItem: (d, f) => {
+      const m = a.findIndex((p) => d === p.value);
+      m !== -1 ? a[m].layout = f[n] : a.push({ value: d, layout: f[n] }), a.sort(Js);
+    },
+    updateOrder: (d, f, m) => {
+      if (u.current)
+        return;
+      const p = Ys(a, d, f, m);
+      a !== p && (u.current = !0, s(p.map(Ks).filter((h) => o.indexOf(h) !== -1)));
+    }
+  };
+  return O(() => {
+    u.current = !1;
+  }), ie(c, { ...r, ref: i, ignoreStrict: !0, children: ie(Ot.Provider, { value: l, children: e }) });
+}
+const $s = /* @__PURE__ */ gt(Xs);
+function Ks(e) {
+  return e.value;
+}
+function Js(e, t) {
+  return e.layout.min - t.layout.min;
+}
+function Ze(e, t = 0) {
+  return D(e) ? e : R(t);
+}
+function Qs({ children: e, style: t = {}, value: n, as: s = "li", onDrag: o, layout: r = !0, ...i }, c) {
+  const a = v(() => vt[s]), u = z(Ot), l = {
+    x: Ze(t.x),
+    y: Ze(t.y)
+  }, d = Ae([l.x, l.y], ([h, g]) => h || g ? 1 : "unset");
+  E(!!u, "Reorder.Item must be a child of Reorder.Group");
+  const { axis: f, registerItem: m, updateOrder: p } = u;
+  return ie(a, { drag: f, ...i, dragSnapToOrigin: !0, style: { ...t, x: l.x, y: l.y, zIndex: d }, layout: r, onDrag: (h, g) => {
+    const { velocity: y } = g;
+    y[f] && p(n, l[f].get(), y[f]), o && o(h, g);
+  }, onLayoutMeasure: (h) => m(n, h), ref: c, ignoreStrict: !0, children: e });
+}
+const Zs = /* @__PURE__ */ gt(Qs), Po = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Group: $s,
+  Item: Zs
+}, Symbol.toStringTag, { value: "Module" }));
+function qs(e, t) {
+  if (e === "first")
+    return 0;
+  {
+    const n = t - 1;
+    return e === "last" ? n : n / 2;
+  }
+}
+function Do(e = 0.1, { startDelay: t = 0, from: n = 0, ease: s } = {}) {
+  return (o, r) => {
+    const i = typeof n == "number" ? n : qs(n, r), c = Math.abs(i - o);
+    let a = e * c;
+    if (s) {
+      const u = r * e;
+      a = vn(s)(a / u) * u;
+    }
+    return t + a;
+  };
+}
+const Ro = A, zo = wn.reduce((e, t) => (e[t] = (n) => K(n), e), {});
+function Fo(e, t = "end") {
+  return (n) => {
+    n = t === "end" ? Math.min(n, 0.999) : Math.max(n, 1e-3);
+    const s = n * e, o = t === "end" ? Math.floor(s) : Math.ceil(s);
+    return ot(0, 1, o / e);
+  };
+}
+export {
+  Ho as AcceleratedAnimation,
+  _o as AnimatePresence,
+  Oo as AnimateSharedLayout,
+  Go as DeprecatedLayoutGroupContext,
+  Rs as DragControls,
+  ko as FlatTree,
+  hn as LayoutGroup,
+  No as LayoutGroupContext,
+  jo as LazyMotion,
+  Uo as MotionConfig,
+  fe as MotionConfigContext,
+  gn as MotionContext,
+  Yo as MotionGlobalConfig,
+  Xo as MotionValue,
+  cn as PresenceContext,
+  Po as Reorder,
+  $o as SwitchLayoutGroupContext,
+  lt as VisualElement,
+  Ko as addPointerEvent,
+  Jo as addPointerInfo,
+  Qo as addScaleCorrector,
+  po as animate,
+  go as animateMini,
+  Nt as animateValue,
+  it as animateVisualElement,
+  as as animationControls,
+  qe as animations,
+  Zo as anticipate,
+  qo as backIn,
+  er as backInOut,
+  tr as backOut,
+  nr as buildTransform,
+  sr as calcLength,
+  K as cancelFrame,
+  zo as cancelSync,
+  or as circIn,
+  rr as circInOut,
+  ir as circOut,
+  ot as clamp,
+  ar as color,
+  cr as complex,
+  ft as createBox,
+  ur as createRendererMotionComponent,
+  It as createScopedAnimate,
+  lr as cubicBezier,
+  fr as delay,
+  Co as disableInstantTransitions,
+  dr as distance,
+  mr as distance2D,
+  pr as domAnimation,
+  hr as domMax,
+  ro as domMin,
+  gr as easeIn,
+  yr as easeInOut,
+  vr as easeOut,
+  wr as filterProps,
+  Sr as findSpring,
+  A as frame,
+  Gt as frameData,
+  Ar as frameSteps,
+  br as hover,
+  _s as inView,
+  Er as inertia,
+  nt as interpolate,
+  E as invariant,
+  Mr as isBrowser,
+  xr as isDragActive,
+  Fs as isMotionComponent,
+  D as isMotionValue,
+  Vr as isValidMotionProp,
+  Cr as keyframes,
+  Ir as m,
+  pn as makeUseVisualState,
+  Tr as mirrorEasing,
+  Or as mix,
+  vt as motion,
+  Y as motionValue,
+  ae as noop,
+  Lr as optimizedAppearDataAttribute,
+  Pr as pipe,
+  Dr as press,
+  tt as progress,
+  Rr as px,
+  zr as resolveMotionValue,
+  Fr as reverseEasing,
+  Qn as scroll,
+  xe as scrollInfo,
+  tn as spring,
+  Do as stagger,
+  Io as startOptimizedAppearAnimation,
+  Fo as steps,
+  Ro as sync,
+  Wr as time,
+  ns as transform,
+  bo as unwrapMotionComponent,
+  ho as useAnimate,
+  yo as useAnimateMini,
+  vo as useAnimation,
+  Ds as useAnimationControls,
+  qn as useAnimationFrame,
+  Mo as useCycle,
+  To as useDeprecatedAnimatedState,
+  Lo as useDeprecatedInvertedScale,
+  So as useDomEvent,
+  Ao as useDragControls,
+  io as useElementScroll,
+  ln as useForceUpdate,
+  xo as useInView,
+  Ws as useInstantLayoutTransition,
+  Vo as useInstantTransition,
+  Br as useIsPresent,
+  le as useIsomorphicLayoutEffect,
+  co as useMotionTemplate,
+  R as useMotionValue,
+  xn as useMotionValueEvent,
+  Hr as usePresence,
+  wo as usePresenceData,
+  os as useReducedMotion,
+  mo as useReducedMotionConfig,
+  Eo as useResetProjection,
+  bt as useScroll,
+  uo as useSpring,
+  lo as useTime,
+  Ae as useTransform,
+  Et as useUnmountEffect,
+  fo as useVelocity,
+  ao as useViewportScroll,
+  _r as useWillChange,
+  re as visualElementStore,
+  Mt as wrap
+};