@beeintel/batch-image 0.0.0-stage → 1.0.0

package/dist/chunks/motionFeatures-D67ghPG1.js

@@ -0,0 +1,4405 @@
+import { n as W, f as M, M as Y, a as we, b as ds, c as z, p as nt, i as Ae, d as q, e as S, g as Kn, h as Ot, t as Ve, j as bt, k as I, l as _n, v as $n, m as Gn, o as Ze, q as Hn, r as De, s as ps, u as Wn, w as ms, x as zn, y as Xn, z as Yn, A as Ut, B as ys, C as qn } from "./entry-CboOSe2r.js";
+function Ce(t, e) {
+  t.indexOf(e) === -1 && t.push(e);
+}
+function Rt(t, e) {
+  const i = t.indexOf(e);
+  i > -1 && t.splice(i, 1);
+}
+function Je(t, e) {
+  return e ? `${t}. For more information and steps for solving, visit https://motion.dev/troubleshooting/${e}` : t;
+}
+let St = () => {
+}, ot = () => {
+};
+typeof process < "u" && process.env?.NODE_ENV !== "production" && (St = (t, e, i) => {
+  !t && typeof console < "u" && console.warn(Je(e, i));
+}, ot = (t, e, i) => {
+  if (!t)
+    throw new Error(Je(e, i));
+});
+const Ee = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t), gs = (t) => typeof t == "object" && t !== null, Me = (t) => /^0[^.\s]+$/u.test(t);
+// @__NO_SIDE_EFFECTS__
+function vs(t) {
+  let e;
+  return () => (e === void 0 && (e = t()), e);
+}
+const wt = (...t) => t.reduce((e, i) => (s) => i(e(s))), gt = /* @__NO_SIDE_EFFECTS__ */ (t, e, i) => {
+  const s = e - t;
+  return s ? (i - t) / s : 1;
+};
+class Lt {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(e) {
+    return Ce(this.subscriptions, e), () => this.remove(e);
+  }
+  remove(e) {
+    Rt(this.subscriptions, e);
+  }
+  notify(e, i, s) {
+    const n = this.subscriptions.length;
+    if (n)
+      if (n === 1)
+        this.subscriptions[0](e, i, s);
+      else
+        for (let r = 0; r < n; r++) {
+          const o = this.subscriptions[r];
+          o && o(e, i, s);
+        }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}
+const K = /* @__NO_SIDE_EFFECTS__ */ (t) => t * 1e3, U = /* @__NO_SIDE_EFFECTS__ */ (t) => t / 1e3, xs = /* @__NO_SIDE_EFFECTS__ */ (t, e) => e ? t * (1e3 / e) : 0, Ts = (t, e, i) => (((1 - 3 * i + 3 * e) * t + (3 * i - 6 * e)) * t + 3 * e) * t, Zn = 1e-7, Jn = 12;
+function Qn(t, e, i, s, n) {
+  let r, o, a = 0;
+  do
+    o = e + (i - e) / 2, r = Ts(o, s, n) - t, r > 0 ? i = o : e = o;
+  while (Math.abs(r) > Zn && ++a < Jn);
+  return o;
+}
+// @__NO_SIDE_EFFECTS__
+function At(t, e, i, s) {
+  if (t === e && i === s)
+    return W;
+  const n = (r) => Qn(r, 0, 1, t, i);
+  return (r) => r === 0 || r === 1 ? r : Ts(n(r), e, s);
+}
+const Ps = /* @__NO_SIDE_EFFECTS__ */ (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, bs = /* @__NO_SIDE_EFFECTS__ */ (t) => (e) => 1 - t(1 - e), Ss = /* @__PURE__ */ At(0.33, 1.53, 0.69, 0.99), Re = /* @__PURE__ */ bs(Ss), ws = /* @__PURE__ */ Ps(Re), As = (t) => t >= 1 ? 1 : (t *= 2) < 1 ? 0.5 * Re(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), Le = (t) => 1 - Math.sin(Math.acos(t)), Vs = /* @__PURE__ */ bs(Le), Ds = /* @__PURE__ */ Ps(Le), to = /* @__PURE__ */ At(0.42, 0, 1, 1), eo = /* @__PURE__ */ At(0, 0, 0.58, 1), ke = /* @__PURE__ */ At(0.42, 0, 0.58, 1), io = /* @__NO_SIDE_EFFECTS__ */ (t) => Array.isArray(t) && typeof t[0] != "number", Cs = /* @__NO_SIDE_EFFECTS__ */ (t) => Array.isArray(t) && typeof t[0] == "number", Qe = {
+  linear: W,
+  easeIn: to,
+  easeInOut: ke,
+  easeOut: eo,
+  circIn: Le,
+  circInOut: Ds,
+  circOut: Vs,
+  backIn: Re,
+  backInOut: ws,
+  backOut: Ss,
+  anticipate: As
+}, so = (t) => typeof t == "string", ti = (t) => {
+  if (/* @__PURE__ */ Cs(t)) {
+    ot(t.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+    const [e, i, s, n] = t;
+    return /* @__PURE__ */ At(e, i, s, n);
+  } else if (so(t))
+    return ot(Qe[t] !== void 0, `Invalid easing type '${t}'`, "invalid-easing-type"), Qe[t];
+  return t;
+};
+let Dt;
+function no() {
+  Dt = void 0;
+}
+const B = {
+  now: () => (Dt === void 0 && B.set(M.isProcessing || Y.useManualTiming ? M.timestamp : performance.now()), Dt),
+  set: (t) => {
+    Dt = t, queueMicrotask(no);
+  }
+}, ct = (t) => Math.round(t * 1e5) / 1e5, Be = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function oo(t) {
+  return t == null;
+}
+const ro = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, Fe = (t, e) => (i) => !!(typeof i == "string" && ro.test(i) && i.startsWith(t) || e && !oo(i) && Object.prototype.hasOwnProperty.call(i, e)), Es = (t, e, i) => (s) => {
+  if (typeof s != "string")
+    return s;
+  const [n, r, o, a] = s.match(Be);
+  return {
+    [t]: parseFloat(n),
+    [e]: parseFloat(r),
+    [i]: parseFloat(o),
+    alpha: a !== void 0 ? parseFloat(a) : 1
+  };
+}, ao = (t) => z(0, 255, t), Kt = {
+  ...we,
+  transform: (t) => Math.round(ao(t))
+}, tt = {
+  test: /* @__PURE__ */ Fe("rgb", "red"),
+  parse: /* @__PURE__ */ Es("red", "green", "blue"),
+  transform: ({ red: t, green: e, blue: i, alpha: s = 1 }) => "rgba(" + Kt.transform(t) + ", " + Kt.transform(e) + ", " + Kt.transform(i) + ", " + ct(ds.transform(s)) + ")"
+};
+function lo(t) {
+  let e = "", i = "", s = "", n = "";
+  return t.length > 5 ? (e = t.substring(1, 3), i = t.substring(3, 5), s = t.substring(5, 7), n = t.substring(7, 9)) : (e = t.substring(1, 2), i = t.substring(2, 3), s = t.substring(3, 4), n = t.substring(4, 5), e += e, i += i, s += s, n += n), {
+    red: parseInt(e, 16),
+    green: parseInt(i, 16),
+    blue: parseInt(s, 16),
+    alpha: n ? parseInt(n, 16) / 255 : 1
+  };
+}
+const ee = {
+  test: /* @__PURE__ */ Fe("#"),
+  parse: lo,
+  transform: tt.transform
+}, at = {
+  test: /* @__PURE__ */ Fe("hsl", "hue"),
+  parse: /* @__PURE__ */ Es("hue", "saturation", "lightness"),
+  transform: ({ hue: t, saturation: e, lightness: i, alpha: s = 1 }) => "hsla(" + Math.round(t) + ", " + nt.transform(ct(e)) + ", " + nt.transform(ct(i)) + ", " + ct(ds.transform(s)) + ")"
+}, R = {
+  test: (t) => tt.test(t) || ee.test(t) || at.test(t),
+  parse: (t) => tt.test(t) ? tt.parse(t) : at.test(t) ? at.parse(t) : ee.parse(t),
+  transform: (t) => typeof t == "string" ? t : t.hasOwnProperty("red") ? tt.transform(t) : at.transform(t),
+  getAnimatableNone: (t) => {
+    const e = R.parse(t);
+    return e.alpha = 0, R.transform(e);
+  }
+}, co = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu, Ms = /* @__PURE__ */ new RegExp(Be.source), Rs = /* @__PURE__ */ new RegExp(co.source, "i");
+function uo(t) {
+  return isNaN(t) && typeof t == "string" && (Ms.test(t) || Rs.test(t));
+}
+const Ls = "number", ks = "color", ho = "var", fo = "var(", ei = "${}", po = /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 mo(t) {
+  const e = t.toString();
+  return Ms.test(e) || Rs.test(e);
+}
+function vt(t) {
+  const e = t.toString(), i = [], s = {
+    color: [],
+    number: [],
+    var: []
+  }, n = [];
+  let r = 0;
+  const a = e.replace(po, (l) => (R.test(l) ? (s.color.push(r), n.push(ks), i.push(R.parse(l))) : l.startsWith(fo) ? (s.var.push(r), n.push(ho), i.push(l)) : (s.number.push(r), n.push(Ls), i.push(parseFloat(l))), ++r, ei)).split(ei);
+  return { values: i, split: a, indexes: s, types: n };
+}
+function yo(t) {
+  return vt(t).values;
+}
+function Bs({ split: t, types: e }) {
+  const i = t.length;
+  return (s) => {
+    let n = "";
+    for (let r = 0; r < i; r++)
+      if (n += t[r], s[r] !== void 0) {
+        const o = e[r];
+        o === Ls ? n += ct(s[r]) : o === ks ? n += R.transform(s[r]) : n += s[r];
+      }
+    return n;
+  };
+}
+function go(t) {
+  return Bs(vt(t));
+}
+const vo = (t) => typeof t == "number" ? 0 : R.test(t) ? R.getAnimatableNone(t) : t, xo = (t, e) => typeof t == "number" ? e?.trim().endsWith("/") ? t : 0 : vo(t);
+function To(t) {
+  const e = vt(t);
+  return Bs(e)(e.values.map((s, n) => xo(s, e.split[n])));
+}
+const j = {
+  test: uo,
+  parse: yo,
+  createTransformer: go,
+  getAnimatableNone: To
+};
+function _t(t, e, i) {
+  return i < 0 && (i += 1), i > 1 && (i -= 1), i < 1 / 6 ? t + (e - t) * 6 * i : i < 1 / 2 ? e : i < 2 / 3 ? t + (e - t) * (2 / 3 - i) * 6 : t;
+}
+function Po({ hue: t, saturation: e, lightness: i, alpha: s }) {
+  t /= 360, e /= 100, i /= 100;
+  let n = 0, r = 0, o = 0;
+  if (!e)
+    n = r = o = i;
+  else {
+    const a = i < 0.5 ? i * (1 + e) : i + e - i * e, l = 2 * i - a;
+    n = _t(l, a, t + 1 / 3), r = _t(l, a, t), o = _t(l, a, t - 1 / 3);
+  }
+  return {
+    red: Math.round(n * 255),
+    green: Math.round(r * 255),
+    blue: Math.round(o * 255),
+    alpha: s
+  };
+}
+function kt(t, e) {
+  return (i) => i > 0 ? e : t;
+}
+const w = (t, e, i) => t + (e - t) * i, $t = (t, e, i) => {
+  const s = t * t, n = i * (e * e - s) + s;
+  return n < 0 ? 0 : Math.sqrt(n);
+}, bo = [ee, tt, at], So = (t) => bo.find((e) => e.test(t));
+function ii(t) {
+  const e = So(t);
+  if (!e)
+    return St(!1, `'${t}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !1;
+  let i = e.parse(t);
+  return e === at && (i = Po(i)), i;
+}
+const si = (t, e) => {
+  const i = ii(t), s = ii(e);
+  if (!i || !s)
+    return kt(t, e);
+  const n = { ...i };
+  return (r) => (n.red = $t(i.red, s.red, r), n.green = $t(i.green, s.green, r), n.blue = $t(i.blue, s.blue, r), n.alpha = w(i.alpha, s.alpha, r), tt.transform(n));
+}, ie = /* @__PURE__ */ new Set(["none", "hidden"]);
+function wo(t, e) {
+  return ie.has(t) ? (i) => i <= 0 ? t : e : (i) => i >= 1 ? e : t;
+}
+function Ao(t, e) {
+  return (i) => w(t, e, i);
+}
+function Ie(t) {
+  return typeof t == "number" ? Ao : typeof t == "string" ? Ae(t) ? kt : R.test(t) ? si : Co : Array.isArray(t) ? Fs : typeof t == "object" ? R.test(t) ? si : Vo : kt;
+}
+function Fs(t, e) {
+  const i = [...t], s = i.length, n = t.map((r, o) => Ie(r)(r, e[o]));
+  return (r) => {
+    for (let o = 0; o < s; o++)
+      i[o] = n[o](r);
+    return i;
+  };
+}
+function Vo(t, e) {
+  const i = { ...t, ...e }, s = {};
+  for (const n in i)
+    t[n] !== void 0 && e[n] !== void 0 && (s[n] = Ie(t[n])(t[n], e[n]));
+  return (n) => {
+    for (const r in s)
+      i[r] = s[r](n);
+    return i;
+  };
+}
+function Do(t, e) {
+  const i = [], s = { color: 0, var: 0, number: 0 };
+  for (let n = 0; n < e.values.length; n++) {
+    const r = e.types[n], o = t.indexes[r][s[r]], a = t.values[o] ?? 0;
+    i[n] = a, s[r]++;
+  }
+  return i;
+}
+const Co = (t, e) => {
+  const i = j.createTransformer(e), s = vt(t), n = vt(e);
+  return s.indexes.var.length === n.indexes.var.length && s.indexes.color.length === n.indexes.color.length && s.indexes.number.length >= n.indexes.number.length ? ie.has(t) && !n.values.length || ie.has(e) && !s.values.length ? wo(t, e) : wt(Fs(Do(s, n), n.values), i) : (St(!0, `Complex values '${t}' and '${e}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different"), kt(t, e));
+}, ni = /^(-?(?:\d+(?:\.\d*)?|\.\d+))([a-z%]*)$/iu;
+function Eo(t, e) {
+  const i = ni.exec(t);
+  if (!i)
+    return;
+  const s = ni.exec(e);
+  if (!s || i[2] !== s[2])
+    return;
+  const n = i[2], r = parseFloat(i[1]), o = parseFloat(s[1]);
+  return (a) => ct(w(r, o, a)) + n;
+}
+function je(t, e, i) {
+  if (typeof t == "number" && typeof e == "number" && typeof i == "number")
+    return w(t, e, i);
+  if (typeof t == "string" && typeof e == "string") {
+    const n = Eo(t, e);
+    if (n)
+      return n;
+  }
+  return Ie(t)(t, e);
+}
+const Mo = (t) => {
+  const e = ({ timestamp: i }) => t(i);
+  return {
+    start: (i = !0) => S.update(e, i),
+    stop: () => q(e),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => M.isProcessing ? M.timestamp : B.now()
+  };
+}, Is = (t, e, i = 10) => {
+  let s = "";
+  const n = Math.max(Math.round(e / i), 2);
+  for (let r = 0; r < n; r++)
+    s += Math.round(t(r / (n - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${s.substring(0, s.length - 2)})`;
+}, Oe = 2e4;
+function Ne(t, e = 50, i = Oe, s) {
+  let n = 0, r = t.next(n);
+  for (; !r.done && n < i; )
+    n += e, r = t.next(n);
+  return n >= i ? 1 / 0 : n;
+}
+function Ro(t, e = 100, i) {
+  const s = i({ ...t, keyframes: [0, e] }), n = Math.min(Ne(s), Oe);
+  return {
+    type: "keyframes",
+    ease: (r) => s.next(n * r).value / e,
+    duration: /* @__PURE__ */ U(n)
+  };
+}
+const L = {
+  // Default spring physics
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  // Default duration/bounce-based options
+  duration: 800,
+  // in ms
+  bounce: 0.3,
+  visualDuration: 0.3,
+  // in seconds
+  // Rest thresholds
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  // Limits
+  minDuration: 0.01,
+  // in seconds
+  maxDuration: 10,
+  // in seconds
+  minDamping: 0.05,
+  maxDamping: 1
+};
+function se(t, e) {
+  return t * Math.sqrt(1 - e * e);
+}
+const Lo = 12;
+function ko(t, e, i) {
+  let s = i;
+  for (let n = 1; n < Lo; n++)
+    s = s - t(s) / e(s);
+  return s;
+}
+const Gt = 1e-3;
+function Bo({ duration: t = L.duration, bounce: e = L.bounce }) {
+  let i, s;
+  St(t <= /* @__PURE__ */ K(L.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let n = 1 - e;
+  n = z(L.minDamping, L.maxDamping, n), t = z(L.minDuration, L.maxDuration, /* @__PURE__ */ U(t)), n < 1 ? (i = (l) => {
+    const u = l * n, c = u * t, h = se(l, n), f = Math.exp(-c);
+    return Gt - u / h * f;
+  }, s = (l) => {
+    const c = l * n * t, h = n * n * l * l * t, f = Math.exp(-c), m = se(l * l, n);
+    return (-i(l) + Gt > 0 ? -1 : 1) * -h * f / m;
+  }) : (i = (l) => {
+    const u = Math.exp(-l * t), c = l * t + 1;
+    return -Gt + u * c;
+  }, s = (l) => {
+    const u = Math.exp(-l * t), c = -l * (t * t);
+    return u * c;
+  });
+  const r = 5 / t, o = ko(i, s, r), a = o * o;
+  return {
+    stiffness: a,
+    damping: n * 2 * Math.sqrt(a),
+    duration: /* @__PURE__ */ K(t)
+  };
+}
+const ne = (t, e) => (e ? t >= 0 : t > 0) && t < 1 / 0;
+function Ht(t, e) {
+  if (ne(t, e))
+    return t;
+}
+function Fo(t) {
+  const e = Ht(t.stiffness), i = Ht(t.damping, !0), s = Ht(t.mass), n = {
+    ...t,
+    stiffness: e ?? L.stiffness,
+    damping: i ?? L.damping,
+    mass: s ?? L.mass,
+    isResolvedFromDuration: !1,
+    // stiffness/damping/mass overrides duration/bounce
+    isTimeDefined: (e ?? i ?? s) === void 0 && (t.duration !== void 0 || t.bounce !== void 0)
+  };
+  if (n.isTimeDefined) {
+    if (t.visualDuration) {
+      const r = 2 * Math.PI / (t.visualDuration * 1.2);
+      n.stiffness = r * r, n.damping = 2 * z(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(n.stiffness);
+    } else
+      Object.assign(n, Bo(n)), n.isResolvedFromDuration = !0;
+    (!ne(n.stiffness) || !ne(n.damping, !0)) && (n.stiffness = L.stiffness, n.damping = L.damping);
+  }
+  return n;
+}
+function Bt(t = L.visualDuration, e = L.bounce) {
+  const i = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: e
+  } : t, s = i.keyframes[0], n = i.keyframes[i.keyframes.length - 1], r = { done: !1, value: s }, { stiffness: o, damping: a, mass: l, duration: u, isResolvedFromDuration: c, isTimeDefined: h } = Fo({ ...i }), f = (y) => h ? 0 : -/* @__PURE__ */ U(y), m = a / (2 * Math.sqrt(o * l)), d = /* @__PURE__ */ U(Math.sqrt(o / l)), v = m * d, p = {
+    target: n,
+    delta: n - s,
+    velocity: f(i.velocity || 0) || 0,
+    restSpeed: 0,
+    restDelta: 0
+  }, x = () => {
+    const y = Math.abs(p.delta) < 5;
+    p.restSpeed = i.restSpeed || (y ? L.restSpeed.granular : L.restSpeed.default), p.restDelta = i.restDelta || (y ? L.restDelta.granular : L.restDelta.default);
+  };
+  x();
+  let T, P, b;
+  if (m < 1) {
+    const y = se(d, m), g = { A: 0, sinC: 0, cosC: 0, t: -1, env: 0, sin: 0, cos: 0 };
+    b = () => {
+      g.A = (p.velocity + v * p.delta) / y, g.sinC = v * g.A + p.delta * y, g.cosC = v * p.delta - g.A * y;
+    };
+    const C = (V) => {
+      V !== g.t && (g.t = V, g.env = Math.exp(-v * V), g.sin = Math.sin(y * V), g.cos = Math.cos(y * V));
+    };
+    T = (V) => (C(V), p.target - g.env * (g.A * g.sin + p.delta * g.cos)), P = (V) => (C(V), g.env * (g.sinC * g.sin + g.cosC * g.cos));
+  } else if (m === 1) {
+    T = (g) => p.target - Math.exp(-d * g) * (p.delta + (p.velocity + d * p.delta) * g);
+    const y = { C: 0 };
+    b = () => {
+      y.C = p.velocity + d * p.delta;
+    }, P = (g) => Math.exp(-d * g) * (d * y.C * g - p.velocity);
+  } else {
+    const y = d * Math.sqrt(m * m - 1);
+    T = (C) => {
+      const V = Math.exp(-v * C), O = Math.min(y * C, 300);
+      return p.target - V * ((p.velocity + v * p.delta) * Math.sinh(O) + y * p.delta * Math.cosh(O)) / y;
+    };
+    const g = { P: 0, sinh: 0, cosh: 0 };
+    b = () => {
+      g.P = (p.velocity + v * p.delta) / y, g.sinh = v * g.P - p.delta * y, g.cosh = v * p.delta - g.P * y;
+    }, P = (C) => {
+      const V = Math.exp(-v * C), O = Math.min(y * C, 300);
+      return V * (g.sinh * Math.sinh(O) + g.cosh * Math.cosh(O));
+    };
+  }
+  b();
+  const A = c && u || null, D = {
+    calculatedDuration: A,
+    /**
+     * Aim the spring at a new target from its current position and
+     * velocity, reusing the resolved physics and closures.
+     */
+    retarget: (y, g) => {
+      p.target = y[y.length - 1], p.delta = p.target - y[0], p.velocity = f(g), i.restSpeed && i.restDelta || x(), D.calculatedDuration = A, r.done = !1, b();
+    },
+    velocity: (y) => /* @__PURE__ */ K(P(y)),
+    next: (y) => {
+      const g = T(y);
+      if (c)
+        r.done = y >= u;
+      else {
+        const C = /* @__PURE__ */ K(P(y));
+        r.done = Math.abs(C) <= p.restSpeed && Math.abs(p.target - g) <= p.restDelta;
+      }
+      return r.value = r.done ? p.target : g, r;
+    },
+    toString: () => {
+      const y = Math.min(Ne(D), Oe), g = Is((C) => D.next(y * C).value, y, 30);
+      return y + "ms " + g;
+    },
+    toTransition: () => {
+    }
+  };
+  return D;
+}
+Bt.applyToOptions = (t) => {
+  const e = Ro(t, 100, Bt);
+  return t.ease = e.ease, t.duration = /* @__PURE__ */ K(e.duration), t.type = "keyframes", t;
+};
+function oe({ keyframes: t, velocity: e = 0, power: i = 0.8, timeConstant: s = 325, bounceDamping: n = 10, bounceStiffness: r = 500, modifyTarget: o, min: a, max: l, restDelta: u = 0.5, restSpeed: c }) {
+  const h = t[0], f = {
+    done: !1,
+    value: h
+  }, m = (y) => y < a || y > l, d = (y) => a === void 0 ? l : l === void 0 || Math.abs(a - y) < Math.abs(l - y) ? a : l;
+  let v = i * e;
+  const p = h + v, x = o === void 0 ? p : o(p);
+  x !== p && (v = x - h);
+  const T = (y) => -v * Math.exp(-y / s), P = (y) => {
+    const g = T(y);
+    f.done = Math.abs(g) <= u, f.value = f.done ? x : x + g;
+  };
+  let b, A;
+  const D = (y) => {
+    m(f.value) && (b = y, A = Bt({
+      keyframes: [f.value, d(f.value)],
+      /**
+       * The friction curve is target + calcDelta(t), so its exact
+       * derivative is -calcDelta(t) / timeConstant in units/ms,
+       * converted here to the units/second expected by spring.
+       */
+      velocity: -T(y) / s * 1e3,
+      damping: n,
+      stiffness: r,
+      restDelta: u,
+      restSpeed: c
+    }));
+  };
+  return D(0), {
+    calculatedDuration: null,
+    next: (y) => {
+      let g = !1;
+      return !A && b === void 0 && (g = !0, P(y), D(y)), b !== void 0 && y >= b ? A.next(y - b) : (!g && P(y), f);
+    }
+  };
+}
+function Io(t, e, i) {
+  const s = [], n = i || Y.mix || je, r = t.length - 1;
+  for (let o = 0; o < r; o++) {
+    let a = n(t[o], t[o + 1]);
+    if (e) {
+      const l = Array.isArray(e) ? e[o] || W : e;
+      a = wt(l, a);
+    }
+    s.push(a);
+  }
+  return s;
+}
+function jo(t, e, { clamp: i = !0, ease: s, mixer: n } = {}) {
+  const r = t.length;
+  if (ot(r === e.length, "Both input and output ranges must be the same length", "range-length"), r === 1)
+    return () => e[0];
+  if (r === 2 && e[0] === e[1])
+    return () => e[1];
+  const o = t[0] === t[1];
+  t[0] > t[r - 1] && (t = [...t].reverse(), e = [...e].reverse());
+  const a = Io(e, s, n), l = a.length, u = (c) => {
+    if (o && c < t[0])
+      return e[0];
+    let h = 0;
+    if (l > 1)
+      for (; h < t.length - 2 && !(c < t[h + 1]); h++)
+        ;
+    const f = /* @__PURE__ */ gt(t[h], t[h + 1], c);
+    return a[h](f);
+  };
+  return i ? (c) => u(z(t[0], t[r - 1], c)) : u;
+}
+function Oo(t, e) {
+  const i = t[t.length - 1];
+  for (let s = 1; s <= e; s++) {
+    const n = /* @__PURE__ */ gt(0, e, s);
+    t.push(w(i, 1, n));
+  }
+}
+function No(t) {
+  const e = [0];
+  return Oo(e, t.length - 1), e;
+}
+function Uo(t, e) {
+  return t.map((i) => i * e);
+}
+function Ko(t, e) {
+  return t.map(() => e || ke).splice(0, t.length - 1);
+}
+function pt({ duration: t = 300, keyframes: e, times: i, ease: s = "easeInOut" }) {
+  const n = /* @__PURE__ */ io(s) ? s.map(ti) : ti(s) || ke, r = {
+    done: !1,
+    value: e[0]
+  };
+  if (e.length === 2 && !Array.isArray(n) && (!i || i.length !== 2 || i[0] === 0 && i[1] === 1)) {
+    const [l, u] = e, c = l === u ? void 0 : (Y.mix || je)(l, u);
+    return {
+      calculatedDuration: t,
+      next: (h) => (r.value = c ? c(n(t > 0 ? z(0, 1, h / t) : 1)) : u, r.done = h >= t, r)
+    };
+  }
+  const o = Uo(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    i && i.length === e.length ? i : No(e),
+    t
+  ), a = jo(o, e, {
+    ease: Array.isArray(n) ? n : Ko(e, n)
+  });
+  return {
+    calculatedDuration: t,
+    next: (l) => (r.value = a(l), r.done = l >= t, r)
+  };
+}
+const _o = 5;
+function $o(t, e, i) {
+  const s = Math.max(e - _o, 0);
+  return /* @__PURE__ */ xs(i - t(s), e - s);
+}
+function Go(t, e, i = 0) {
+  return e <= 0 ? i : t.velocity ? t.velocity(e) : $o((s) => t.next(s).value, e, t.next(e).value);
+}
+const Ho = (t) => t !== null;
+function Nt(t, { repeat: e, repeatType: i = "loop" }, s, n = 1) {
+  const r = t.filter(Ho), a = n < 0 || e && i !== "loop" && e % 2 === 1 ? 0 : r.length - 1;
+  return !a || s === void 0 ? r[a] : s;
+}
+const Wo = {
+  decay: oe,
+  inertia: oe,
+  tween: pt,
+  keyframes: pt,
+  spring: Bt
+};
+function js(t) {
+  typeof t.type == "string" && (t.type = Wo[t.type]);
+}
+function Os(t, e) {
+  return {
+    kind: t,
+    animation: e,
+    timestamp: B.now(),
+    frameTimestamp: M.timestamp,
+    frameIsProcessing: M.isProcessing
+  };
+}
+function Ns(t, e, i) {
+  const s = globalThis.__MOTION_INSPECT__;
+  if (s)
+    try {
+      s({
+        ...Os("animation-start", t),
+        options: i ? { ...e, ...i } : e
+      });
+    } catch {
+    }
+}
+function zo(t, e) {
+  const i = globalThis.__MOTION_INSPECT__;
+  if (i)
+    try {
+      i({
+        ...Os("layout-animation-start", t),
+        node: e
+      });
+    } catch {
+    }
+}
+class Ue {
+  constructor() {
+    this.isResolved = !1;
+  }
+  get finished() {
+    return this._finished || (this._finished = this.isResolved ? Promise.resolve() : new Promise((e) => {
+      this._resolve = e;
+    })), this._finished;
+  }
+  updateFinished() {
+    this._finished = this._resolve = void 0, this.isResolved = !1;
+  }
+  notifyFinished() {
+    this.isResolved = !0, this._resolve?.();
+  }
+  /**
+   * Allows the animation to be awaited.
+   *
+   * @deprecated Use `finished` instead.
+   */
+  then(e, i) {
+    return this.finished.then(e, i);
+  }
+}
+const Xo = (t) => t / 100;
+class Ft extends Ue {
+  constructor(e) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+      done: !1,
+      value: void 0
+    }, this.stop = () => {
+      const { motionValue: i } = this.options;
+      i && i.updatedAt !== B.now() && this.tick(B.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause(), Ns(this, this.options);
+  }
+  initAnimation() {
+    const { options: e } = this;
+    js(e);
+    const { type: i = pt, repeat: s = 0, repeatDelay: n = 0, repeatType: r, velocity: o = 0 } = e;
+    let { keyframes: a } = e;
+    const l = i || pt;
+    l !== pt && typeof a[0] != "number" && (this.mixKeyframes = wt(Xo, je(a[0], a[1])), a = [0, 100]);
+    const u = l(a === e.keyframes ? e : { ...e, keyframes: a });
+    r === "mirror" && (this.mirroredGenerator = l({
+      ...e,
+      keyframes: [...a].reverse(),
+      velocity: -o
+    })), u.calculatedDuration === null && (u.calculatedDuration = Ne(u));
+    const { calculatedDuration: c } = u;
+    this.calculatedDuration = c, this.resolvedDuration = c + n, this.totalDuration = this.resolvedDuration * (s + 1) - n, this.generator = u;
+  }
+  updateTime(e) {
+    const i = Math.round(e - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = i;
+  }
+  tick(e, i = !1) {
+    const { generator: s, totalDuration: n, mixKeyframes: r, mirroredGenerator: o, resolvedDuration: a, calculatedDuration: l } = this;
+    if (this.startTime === null)
+      return s.next(0);
+    const { delay: u = 0, keyframes: c, repeat: h, repeatType: f, repeatDelay: m, type: d, onUpdate: v, finalKeyframe: p } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - n / this.speed, this.startTime)), i ? this.currentTime = e : this.updateTime(e);
+    const x = this.currentTime - u * (this.playbackSpeed >= 0 ? 1 : -1), T = this.playbackSpeed >= 0 ? x < 0 : x > n;
+    this.currentTime = Math.max(x, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = n);
+    let P = this.currentTime, b = s;
+    if (h) {
+      const g = Math.min(this.currentTime, n) / a;
+      let C = Math.floor(g), V = g % 1;
+      !V && g >= 1 && (V = 1), V === 1 && C--, C = Math.min(C, h + 1), !!(C % 2) && (f === "reverse" ? (V = 1 - V, m && (V -= m / a)) : f === "mirror" && (b = o)), P = z(0, 1, V) * a;
+    }
+    let A;
+    T ? (this.delayState.value = c[0], A = this.delayState) : A = b.next(P), r && !T && (A.value = r(A.value));
+    let { done: D } = A;
+    !T && l !== null && (D = this.playbackSpeed >= 0 ? this.currentTime >= n : this.currentTime <= 0);
+    const y = this.holdTime === null && (this.state === "finished" || this.state === "running" && D);
+    return y && d !== oe && (A.value = Nt(c, this.options, p, this.speed)), v && v(A.value), y && this.finish(), 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(e, i) {
+    return this.finished.then(e, i);
+  }
+  get duration() {
+    return /* @__PURE__ */ U(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: e = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ U(e);
+  }
+  get time() {
+    return /* @__PURE__ */ U(this.currentTime);
+  }
+  set time(e) {
+    e = /* @__PURE__ */ K(e), this.currentTime = e, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = e, this.tick(e));
+  }
+  /**
+   * Returns the generator's velocity at the current time in units/second.
+   * Uses the analytical derivative when available (springs), avoiding
+   * the MotionValue's frame-dependent velocity estimation.
+   */
+  getGeneratorVelocity() {
+    return Go(this.generator, this.currentTime, this.options.velocity);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(e) {
+    const i = this.playbackSpeed !== e;
+    i && this.driver && this.updateTime(B.now()), this.playbackSpeed = e, i && this.driver && (this.time = /* @__PURE__ */ U(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: e = Mo, startTime: i } = this.options;
+    this.driver || (this.driver = e((n) => this.tick(n))), this.options.onPlay?.();
+    const s = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = i ?? s), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(B.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(e) {
+    return this.startTime = 0, this.tick(e, !0);
+  }
+  attachTimeline(e) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), e.observe(this);
+  }
+}
+const Yo = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function qo(t) {
+  const [e, i] = t.slice(0, -1).split("(");
+  if (e === "drop-shadow")
+    return t;
+  const [s] = i.match(Be) || [];
+  if (!s)
+    return t;
+  const n = i.replace(s, "");
+  let r = Yo.has(e) ? 1 : 0;
+  return s !== i && (r *= 100), e + "(" + r + n + ")";
+}
+const Zo = /\b([a-z-]*)\(.*?\)/gu, re = {
+  ...j,
+  getAnimatableNone: (t) => {
+    const e = t.match(Zo);
+    return e ? e.map(qo).join(" ") : t;
+  }
+}, ae = {
+  ...j,
+  getAnimatableNone: (t) => {
+    const e = j.parse(t);
+    return j.createTransformer(t)(e.map((s) => typeof s == "number" ? 0 : typeof s == "object" ? { ...s, alpha: 1 } : s));
+  }
+}, Jo = {
+  ...Kn,
+  // Color props
+  color: R,
+  backgroundColor: R,
+  outlineColor: R,
+  fill: R,
+  stroke: R,
+  // Border props
+  borderColor: R,
+  borderTopColor: R,
+  borderRightColor: R,
+  borderBottomColor: R,
+  borderLeftColor: R,
+  filter: re,
+  WebkitFilter: re,
+  mask: ae,
+  WebkitMask: ae
+}, Us = (t) => Jo[t], Qo = /* @__PURE__ */ new Set([re, ae]);
+function Ke(t, e) {
+  let i = Us(t);
+  return Qo.has(i) || (i = j), i.getAnimatableNone ? i.getAnimatableNone(e) : void 0;
+}
+function tr(t) {
+  for (let e = 1; e < t.length; e++)
+    t[e] ?? (t[e] = t[e - 1]);
+}
+const et = (t) => t * 180 / Math.PI, le = (t) => {
+  const e = et(Math.atan2(t[1], t[0]));
+  return ce(e);
+}, er = {
+  x: 4,
+  y: 5,
+  translateX: 4,
+  translateY: 5,
+  scaleX: 0,
+  scaleY: 3,
+  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
+  rotate: le,
+  rotateZ: le,
+  skewX: (t) => et(Math.atan(t[1])),
+  skewY: (t) => et(Math.atan(t[2])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
+}, ce = (t) => (t = t % 360, t < 0 && (t += 360), t), oi = le, ri = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), ai = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), ir = {
+  x: 12,
+  y: 13,
+  z: 14,
+  translateX: 12,
+  translateY: 13,
+  translateZ: 14,
+  scaleX: ri,
+  scaleY: ai,
+  scale: (t) => (ri(t) + ai(t)) / 2,
+  rotateX: (t) => ce(et(Math.atan2(t[6], t[5]))),
+  rotateY: (t) => ce(et(Math.atan2(-t[2], t[0]))),
+  rotateZ: oi,
+  rotate: oi,
+  skewX: (t) => et(Math.atan(t[4])),
+  skewY: (t) => et(Math.atan(t[1])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
+};
+function ue(t) {
+  return t.includes("scale") ? 1 : 0;
+}
+function he(t, e) {
+  if (!t || t === "none")
+    return ue(e);
+  const i = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
+  let s, n;
+  if (i)
+    s = ir, n = i;
+  else {
+    const a = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+    s = er, n = a;
+  }
+  if (!n)
+    return ue(e);
+  const r = s[e], o = n[1].split(",").map(nr);
+  return typeof r == "function" ? r(o) : o[r];
+}
+const sr = (t, e) => {
+  const { transform: i = "none" } = getComputedStyle(t);
+  return he(i, e);
+};
+function nr(t) {
+  return parseFloat(t.trim());
+}
+const li = (t) => t === we || t === Ot, or = /* @__PURE__ */ new Set(["x", "y", "z"]), rr = Ve.filter((t) => !or.has(t));
+function ar(t) {
+  const e = [];
+  return rr.forEach((i) => {
+    const s = t.getValue(i);
+    if (s !== void 0) {
+      const n = s.get(), r = i.startsWith("scale") ? 1 : 0;
+      if (n === r)
+        return;
+      e.push([i, n]), s.set(r);
+    }
+  }), e;
+}
+const lr = /* @__PURE__ */ new Set(["bottom", "right"]);
+function ci(t, e, i, s, n, r) {
+  const o = parseFloat(t);
+  if (!isNaN(o))
+    return o;
+  const { min: a, max: l } = e()[i], u = l - a;
+  return r === "border-box" ? u : u - parseFloat(s) - parseFloat(n);
+}
+const it = {
+  // Dimensions
+  width: ({ width: t, paddingLeft: e = "0", paddingRight: i = "0", boxSizing: s }, n) => ci(t, n, "x", e, i, s),
+  height: ({ height: t, paddingTop: e = "0", paddingBottom: i = "0", boxSizing: s }, n) => ci(t, n, "y", e, i, s),
+  top: ({ top: t }) => parseFloat(t),
+  left: ({ left: t }) => parseFloat(t),
+  bottom: ({ top: t }, e) => {
+    const { y: i } = e();
+    return parseFloat(t) + (i.max - i.min);
+  },
+  right: ({ left: t }, e) => {
+    const { x: i } = e();
+    return parseFloat(t) + (i.max - i.min);
+  },
+  // Transform
+  x: ({ transform: t }) => he(t, "x"),
+  y: ({ transform: t }) => he(t, "y")
+};
+it.translateX = it.x;
+it.translateY = it.y;
+const st = /* @__PURE__ */ new Set();
+let fe = !1, de = !1, pe = !1;
+function Ks() {
+  if (de) {
+    const t = [], e = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+    st.forEach((n) => {
+      n.needsMeasurement && (t.push(n), e.add(n.element), lr.has(n.name) && i.add(n.element));
+    });
+    const s = /* @__PURE__ */ new Map();
+    i.forEach((n) => {
+      const r = ar(n);
+      r.length && (s.set(n, r), n.render());
+    }), t.forEach((n) => n.measureInitialState()), e.forEach((n) => {
+      n.render();
+      const r = s.get(n);
+      r && r.forEach(([o, a]) => {
+        n.getValue(o)?.set(a);
+      });
+    }), t.forEach((n) => n.measureEndState()), t.forEach((n) => {
+      n.suspendedScrollY !== void 0 && window.scrollTo(0, n.suspendedScrollY);
+    });
+  }
+  de = !1, fe = !1, st.forEach((t) => t.complete(pe)), st.clear();
+}
+function _s() {
+  st.forEach((t) => {
+    t.readKeyframes(), t.needsMeasurement && (de = !0);
+  });
+}
+function cr() {
+  pe = !0, _s(), Ks(), pe = !1;
+}
+function ur(t, e, i) {
+  if (typeof t == "string") {
+    if (Ee(t) || Me(t))
+      return parseFloat(t);
+    if (!j.test(t) && j.test(i))
+      return Ke(e, i);
+  }
+  return t ?? void 0;
+}
+class _e {
+  constructor(e, i, s, n, r, o = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...e], this.onComplete = i, this.name = s, this.motionValue = n, this.element = r, this.isAsync = o;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (st.add(this), fe || (fe = !0, S.read(_s), S.resolveKeyframes(Ks))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, name: i, element: s, motionValue: n } = this;
+    if (e[0] === null) {
+      const r = n?.get(), o = e[e.length - 1];
+      if (r !== void 0)
+        e[0] = r;
+      else if (s && i) {
+        const a = ur(s.readValue(i, o), i, o);
+        a !== void 0 && (e[0] = a);
+      }
+      e[0] === void 0 && (e[0] = o), n && r === void 0 && n.set(e[0]);
+    }
+    tr(e);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(e = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, e), st.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (st.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}
+const hr = (t) => t.startsWith("--");
+function $s(t, e, i) {
+  hr(e) ? t.style.setProperty(e, i) : t.style[e] = i;
+}
+const fr = {};
+function Gs(t, e) {
+  const i = /* @__PURE__ */ vs(t);
+  return () => fr[e] ?? i();
+}
+const dr = /* @__PURE__ */ Gs(() => window.ScrollTimeline !== void 0, "scrollTimeline"), Hs = /* @__PURE__ */ Gs(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing"), ft = ([t, e, i, s]) => `cubic-bezier(${t}, ${e}, ${i}, ${s})`, ui = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ ft([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ ft([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ ft([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ ft([0.33, 1.53, 0.69, 0.99])
+};
+function Ws(t, e) {
+  if (t)
+    return typeof t == "function" ? Hs() ? Is(t, e) : "ease-out" : /* @__PURE__ */ Cs(t) ? ft(t) : Array.isArray(t) ? t.map((i) => Ws(i, e) || ui.easeOut) : ui[t];
+}
+function pr(t, e, i, { delay: s = 0, duration: n = 300, repeat: r = 0, repeatType: o = "loop", ease: a = "easeOut", times: l } = {}, u = void 0) {
+  const c = {
+    [e]: i
+  };
+  l && (c.offset = l);
+  const h = Ws(a, n);
+  Array.isArray(h) && (c.easing = h);
+  const f = {
+    delay: s,
+    duration: n,
+    easing: Array.isArray(h) ? "linear" : h,
+    fill: "both",
+    iterations: r + 1,
+    direction: o === "reverse" ? "alternate" : "normal"
+  };
+  return u && (f.pseudoElement = u), t.animate(c, f);
+}
+function zs(t) {
+  return typeof t == "function" && "applyToOptions" in t;
+}
+function mr({ type: t, ...e }) {
+  return zs(t) && Hs() ? t.applyToOptions(e) : (e.duration ?? (e.duration = 300), e.ease ?? (e.ease = "easeOut"), e);
+}
+class Xs extends Ue {
+  constructor(e) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !e)
+      return;
+    const { element: i, name: s, keyframes: n, pseudoElement: r, allowFlatten: o = !1, finalKeyframe: a, onComplete: l } = e;
+    this.isPseudoElement = !!r, this.allowFlatten = o, this.options = e, ot(typeof e.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
+    const u = mr(e);
+    this.animation = pr(i, s, n, u, r), u.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !r) {
+        const c = Nt(n, this.options, a, this.speed);
+        this.updateMotionValue && this.updateMotionValue(c), $s(i, s, c), this.animation.cancel();
+      }
+      l?.(), this.notifyFinished();
+    }, Ns(this, e, u);
+  }
+  play() {
+    this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.finish?.();
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: e } = this;
+    e === "idle" || e === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * In this method, we commit styles back to the DOM before cancelling
+   * the animation.
+   *
+   * This is designed to be overridden by NativeAnimationExtended, which
+   * will create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to also correctly calculate velocity for any subsequent animation
+   * while deferring the commit until the next animation frame.
+   */
+  commitStyles() {
+    const e = this.options?.element;
+    !this.isPseudoElement && e?.isConnected && this.animation.commitStyles?.();
+  }
+  get duration() {
+    const e = this.animation.effect?.getComputedTiming?.().duration || 0;
+    return /* @__PURE__ */ U(Number(e));
+  }
+  get iterationDuration() {
+    const { delay: e = 0 } = this.options || {};
+    return this.duration + /* @__PURE__ */ U(e);
+  }
+  get time() {
+    return /* @__PURE__ */ U(Number(this.animation.currentTime) || 0);
+  }
+  set time(e) {
+    const i = this.finishedTime !== null;
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ K(e), i && this.animation.pause();
+  }
+  /**
+   * The playback speed of the animation.
+   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+   */
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(e) {
+    e < 0 && (this.finishedTime = null), this.animation.playbackRate = e;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(e) {
+    this.manualStartTime = this.animation.startTime = e;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: e, rangeStart: i, rangeEnd: s, observe: n }) {
+    return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, e && dr() ? (this.animation.timeline = e, i && (this.animation.rangeStart = i), s && (this.animation.rangeEnd = s), W) : n(this);
+  }
+}
+const Ys = {
+  anticipate: As,
+  backInOut: ws,
+  circInOut: Ds
+};
+function yr(t) {
+  return t in Ys;
+}
+function gr(t) {
+  typeof t.ease == "string" && yr(t.ease) && (t.ease = Ys[t.ease]);
+}
+const Wt = 10;
+class vr extends Xs {
+  constructor(e) {
+    gr(e), js(e), super(e), e.startTime !== void 0 && e.autoplay !== !1 && (this.startTime = e.startTime), this.options = e;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read committed styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
+   */
+  updateMotionValue(e) {
+    const { motionValue: i, onUpdate: s, onComplete: n, element: r, ...o } = this.options;
+    if (!i)
+      return;
+    if (e !== void 0) {
+      i.set(e);
+      return;
+    }
+    const a = new Ft({
+      ...o,
+      autoplay: !1
+    }), l = Math.max(Wt, B.now() - this.startTime), u = z(0, Wt, l - Wt), c = a.sample(l).value, { name: h } = this.options;
+    r && h && $s(r, h, c), i.setWithVelocity(a.sample(Math.max(0, l - u)).value, c, u), a.stop();
+  }
+}
+const hi = (t, e) => e === "zIndex" ? !1 : !!(typeof t == "number" || Array.isArray(t) || typeof t == "string" && // It's animatable if we have a string
+(j.test(t) || t === "0") && // And it contains numbers and/or colors
+!t.startsWith("url("));
+function xr(t) {
+  const e = t[0];
+  if (t.length === 1)
+    return !0;
+  for (let i = 0; i < t.length; i++)
+    if (t[i] !== e)
+      return !0;
+}
+function Tr(t, e, i, s) {
+  const n = t[0];
+  if (n === null)
+    return !1;
+  if (e === "display" || e === "visibility")
+    return !0;
+  const r = t[t.length - 1], o = hi(n, e), a = hi(r, e);
+  return !o || !a ? (o !== a && St(!1, `You are trying to animate ${e} from "${n}" to "${r}". "${o ? r : n}" is not an animatable value.`, "value-not-animatable"), !1) : xr(t) || (i === "spring" || zs(i)) && s;
+}
+function me(t) {
+  t.duration = 0, t.type = "keyframes";
+}
+const ye = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform",
+  "backgroundColor"
+]), Pr = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/;
+function br(t) {
+  for (let e = 0; e < t.length; e++)
+    if (typeof t[e] == "string" && Pr.test(t[e]))
+      return !0;
+  return !1;
+}
+const fi = /* @__PURE__ */ new Set([
+  "color",
+  "backgroundColor",
+  "outlineColor",
+  "fill",
+  "stroke",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor"
+]), Sr = /* @__PURE__ */ vs(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function wr(t) {
+  const { motionValue: e, name: i, repeatDelay: s, repeatType: n, damping: r, type: o, keyframes: a } = t;
+  if (!i || !(ye.has(i) || fi.has(i)))
+    return !1;
+  const l = e?.owner?.current;
+  if (!(l instanceof HTMLElement) && !(l instanceof SVGElement))
+    return !1;
+  const { onUpdate: u, transformTemplate: c } = e.owner.getProps();
+  return Sr() && /**
+   * Force WAAPI for color properties with browser-only color formats
+   * (oklch, oklab, lab, lch, etc.) that the JS animation path can't parse.
+   */
+  (ye.has(i) || fi.has(i) && br(a)) && (i !== "transform" || !c) && /**
+   * If we're outputting values to onUpdate then we can't use WAAPI as there's
+   * no way to read the value from WAAPI every frame.
+   */
+  !u && !s && n !== "mirror" && r !== 0 && o !== "inertia";
+}
+const Ar = 40;
+class Vr extends Ue {
+  constructor(e) {
+    super(), this.stop = () => {
+      this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+    }, this.createdAt = B.now();
+    const { keyframes: i, name: s, motionValue: n, element: r } = e, o = e;
+    o.autoplay ?? (o.autoplay = !0), o.delay ?? (o.delay = 0), o.type ?? (o.type = "keyframes"), o.repeat ?? (o.repeat = 0), o.repeatDelay ?? (o.repeatDelay = 0), o.repeatType ?? (o.repeatType = "loop");
+    const a = r?.KeyframeResolver || _e;
+    this.keyframeResolver = new a(i, (l, u, c) => this.onKeyframesResolved(l, u, o, !c), s, n, r), this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(e, i, s, n) {
+    this.keyframeResolver = void 0;
+    const { name: r, type: o, velocity: a, delay: l, isHandoff: u, onUpdate: c } = s;
+    this.resolvedAt = B.now();
+    let h = !0;
+    Tr(e, r, o, a) || (h = !1, (Y.instantAnimations || !l) && c?.(Nt(e, s, i)), e[0] = e[e.length - 1], me(s), s.repeat = 0);
+    const f = n ? this.resolvedAt ? this.resolvedAt - this.createdAt > Ar ? this.resolvedAt : this.createdAt : this.createdAt : void 0, { onComplete: m } = s;
+    s.startTime ?? (s.startTime = f), s.finalKeyframe = i, s.keyframes = e, s.onComplete = () => {
+      m?.(), this.notifyFinished();
+    };
+    const d = h && !u && wr(s);
+    let v;
+    if (d) {
+      s.element = s.motionValue?.owner?.current;
+      try {
+        v = new vr(s);
+      } catch {
+        v = new Ft(s);
+      }
+    } else
+      v = new Ft(s);
+    this.pendingTimeline && (this.stopTimeline = v.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = v;
+  }
+  get finished() {
+    return this._animation ? this._animation.finished : super.finished;
+  }
+  then(e, i) {
+    return this.finished.finally(e).then(() => {
+    });
+  }
+  get animation() {
+    return this._animation || (this.keyframeResolver?.resume(), cr()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(e) {
+    this.animation.time = e;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(e) {
+    this.animation.speed = e;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(e) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(e) : this.pendingTimeline = e, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+  }
+}
+function qs(t, e, i, s = 0, n = 1) {
+  const r = Array.from(t).sort((u, c) => u.sortNodePosition(c)).indexOf(e), o = t.size, a = (o - 1) * s;
+  return typeof i == "function" ? i(r, o) : n === 1 ? r * s : a - r * s;
+}
+const di = 30, Dr = (t) => !isNaN(parseFloat(t));
+class Cr {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(e, i = {}) {
+    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s) => {
+      const n = B.now();
+      if (this.updatedAt !== n && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && (this.notifyChange(), this.dependents))
+        for (const r of this.dependents)
+          r.dirty();
+    }, this.hasAnimated = !1, this.setCurrent(e), this.owner = i.owner;
+  }
+  setCurrent(e) {
+    this.current = e, this.updatedAt = B.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = Dr(this.current));
+  }
+  setPrevFrameValue(e = this.current) {
+    this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(e) {
+    return this.on("change", e);
+  }
+  on(e, i) {
+    var s;
+    return e === "change" ? this.onChangeSubscribe(i) : ((s = this.events)[e] || (s[e] = new Lt())).add(i);
+  }
+  onChangeSubscribe(e) {
+    const { events: i } = this;
+    return !i.change && !this.changeSubscriber ? this.changeSubscriber = e : (i.change || (i.change = new Lt(), i.change.add(this.changeSubscriber), this.changeSubscriber = void 0), i.change.add(e)), () => {
+      this.changeSubscriber === e ? this.changeSubscriber = void 0 : i.change?.remove(e), this.stopIfUnobserved();
+    };
+  }
+  /**
+   * If we have no more change listeners by the start
+   * of the next frame, stop active animations.
+   */
+  stopIfUnobserved() {
+    S.read(() => {
+      !this.changeSubscriber && !this.events.change?.getSize() && this.stop();
+    });
+  }
+  clearListeners() {
+    this.changeSubscriber = void 0;
+    for (const e in this.events)
+      this.events[e].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   */
+  attach(e, i) {
+    this.passiveEffect = e, this.stopPassiveEffect = i;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(e) {
+    this.passiveEffect ? this.passiveEffect(e, this.updateAndNotify) : this.updateAndNotify(e);
+  }
+  setWithVelocity(e, i, s) {
+    this.set(i), this.prev = void 0, this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt - s;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(e, i = !0) {
+    this.updateAndNotify(e), this.prev = e, this.prevUpdatedAt = this.prevFrameValue = void 0, i && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  dirty() {
+    this.notifyChange();
+  }
+  notifyChange() {
+    const { current: e, changeSubscriber: i } = this;
+    i ? i(e) : this.events.change?.notify(e);
+  }
+  addDependent(e) {
+    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(e);
+  }
+  removeDependent(e) {
+    this.dependents && this.dependents.delete(e);
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const e = B.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > di)
+      return 0;
+    const i = Math.min(this.updatedAt - this.prevUpdatedAt, di);
+    return /* @__PURE__ */ xs(parseFloat(this.current) - parseFloat(this.prevFrameValue), i);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   */
+  start(e) {
+    return this.stop(), new Promise((i) => {
+      this.hasAnimated = !0;
+      let s = !1, n;
+      n = e(() => {
+        s = !0, this.events.animationComplete?.notify(), this.animation === n && this.clearAnimation(), i();
+      }), s || (this.animation = n), this.events.animationStart?.notify();
+    });
+  }
+  /**
+   * 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() {
+    this.animation = void 0;
+  }
+  /**
+   * 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.dependents?.clear(), this.events.destroy?.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function ht(t, e) {
+  return new Cr(t, e);
+}
+function Zs(t, e) {
+  if (t?.inherit && e) {
+    const { inherit: i, ...s } = t;
+    return { ...e, ...s };
+  }
+  return t;
+}
+function $e(t, e) {
+  const i = t?.[e] ?? t?.default ?? t;
+  return i !== t ? Zs(i, t) : i;
+}
+const Er = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, Mr = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), Rr = {
+  type: "keyframes",
+  duration: 0.8
+}, Lr = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, kr = (t, { keyframes: e }) => e.length > 2 ? Rr : bt.has(t) ? t.startsWith("scale") ? Mr(e[1]) : Er : Lr, Br = /* @__PURE__ */ new Set([
+  "when",
+  "delay",
+  "delayChildren",
+  "staggerChildren",
+  "staggerDirection",
+  "repeat",
+  "repeatType",
+  "repeatDelay",
+  "from",
+  "elapsed"
+]);
+function Fr(t) {
+  for (const e in t)
+    if (!Br.has(e))
+      return !0;
+  return !1;
+}
+const Ge = (t, e, i, s = {}, n, r) => (o) => {
+  const a = $e(s, t) || {}, l = a.delay || s.delay || 0;
+  let { elapsed: u = 0 } = s;
+  u = u - /* @__PURE__ */ K(l);
+  const c = {
+    keyframes: Array.isArray(i) ? i : [null, i],
+    ease: "easeOut",
+    velocity: e.getVelocity(),
+    ...a,
+    delay: -u,
+    onUpdate: (f) => {
+      e.set(f), a.onUpdate && a.onUpdate(f);
+    },
+    onComplete: () => {
+      o(), a.onComplete && a.onComplete();
+    },
+    name: t,
+    motionValue: e,
+    element: r ? void 0 : n
+  };
+  Fr(a) || Object.assign(c, kr(t, c)), c.duration && (c.duration = /* @__PURE__ */ K(c.duration)), c.repeatDelay && (c.repeatDelay = /* @__PURE__ */ K(c.repeatDelay)), c.from !== void 0 && (c.keyframes[0] = c.from);
+  let h = !1;
+  if ((c.type === !1 || c.duration === 0 && !c.repeatDelay) && (me(c), c.delay === 0 && (h = !0)), (Y.instantAnimations || Y.skipAnimations || n?.shouldSkipAnimations || a.skipAnimations) && (h = !0, me(c), c.delay = 0), c.allowFlatten = !a.type && !a.ease, h && !r && e.get() !== void 0) {
+    const f = Nt(c.keyframes, a);
+    if (f !== void 0) {
+      S.update(() => {
+        c.onUpdate(f), c.onComplete();
+      });
+      return;
+    }
+  }
+  return a.isSync ? new Ft(c) : new Vr(c);
+}, Ir = (
+  // 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 jr(t) {
+  const e = Ir.exec(t);
+  if (!e)
+    return [,];
+  const [, i, s, n] = e;
+  return [`--${i ?? s}`, n];
+}
+const Or = 4;
+function Js(t, e, i = 1) {
+  ot(i <= Or, `Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [s, n] = jr(t);
+  if (!s)
+    return;
+  const r = window.getComputedStyle(e).getPropertyValue(s);
+  if (r) {
+    const o = r.trim();
+    return Ee(o) ? parseFloat(o) : o;
+  }
+  return Ae(n) ? Js(n, e, i + 1) : n;
+}
+function pi(t) {
+  const e = [{}, {}];
+  return t?.values.forEach((i, s) => {
+    e[0][s] = i.get(), e[1][s] = i.getVelocity();
+  }), e;
+}
+function Qs(t, e, i, s) {
+  if (typeof e == "function") {
+    const [n, r] = pi(s);
+    e = e(i !== void 0 ? i : t.custom, n, r);
+  }
+  if (typeof e == "string" && (e = t.variants && t.variants[e]), typeof e == "function") {
+    const [n, r] = pi(s);
+    e = e(i !== void 0 ? i : t.custom, n, r);
+  }
+  return e;
+}
+function ut(t, e, i) {
+  const s = t.getProps();
+  return Qs(s, e, i !== void 0 ? i : s.custom, t);
+}
+const tn = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...Ve
+]), Nr = (t) => Array.isArray(t);
+function Ur(t, e, i) {
+  t.hasValue(e) ? t.getValue(e).set(i) : t.addValue(e, ht(i));
+}
+function Kr(t) {
+  return Nr(t) ? t[t.length - 1] || 0 : t;
+}
+function _r(t, e) {
+  const i = ut(t, e);
+  let { transitionEnd: s = {}, transition: n = {}, ...r } = i || {};
+  r = { ...r, ...s };
+  for (const o in r) {
+    const a = Kr(r[o]);
+    Ur(t, o, a);
+  }
+}
+function $r(t) {
+  return !!(I(t) && t.add);
+}
+function ge(t, e) {
+  const i = t.getValue("willChange");
+  if ($r(i))
+    return i.add(e);
+  if (!i && Y.WillChange) {
+    const s = new Y.WillChange("auto");
+    t.addValue("willChange", s), s.add(e);
+  }
+}
+function He(t) {
+  return t.replace(/([A-Z])/g, (e) => `-${e.toLowerCase()}`);
+}
+const Gr = "framerAppearId", Hr = "data-" + He(Gr);
+function en(t) {
+  return t.props[Hr];
+}
+const Wr = typeof window < "u";
+function zr({ protectedKeys: t, needsAnimating: e }, i) {
+  const s = t.hasOwnProperty(i) && e[i] !== !0;
+  return e[i] = !1, s;
+}
+function sn(t, e, { delay: i = 0, transitionOverride: s, type: n } = {}) {
+  let { transition: r, transitionEnd: o, ...a } = e;
+  const l = t.getDefaultTransition();
+  r = r ? Zs(r, l) : l;
+  const u = r?.reduceMotion, c = r?.skipAnimations;
+  s && (r = s);
+  const h = [], f = n && t.animationState && t.animationState.getState()[n], m = r?.path;
+  m && m.animateVisualElement(t, a, r, i, h);
+  for (const d in a) {
+    const v = t.getValue(d, t.latestValues[d] ?? null), p = a[d];
+    if (p === void 0 || f && zr(f, d))
+      continue;
+    const x = {
+      delay: i,
+      ...$e(r || {}, d)
+    };
+    c && (x.skipAnimations = !0);
+    const T = v.get();
+    if (T !== void 0 && !v.isAnimating() && !Array.isArray(p) && p === T && !x.velocity) {
+      S.update(() => v.set(p));
+      continue;
+    }
+    let P = !1;
+    if (Wr && window.MotionHandoffAnimation) {
+      const D = en(t);
+      if (D) {
+        const y = window.MotionHandoffAnimation(D, d, S);
+        y !== null && (x.startTime = y, P = !0);
+      }
+    }
+    ge(t, d);
+    const b = u ?? t.shouldReduceMotion;
+    v.start(Ge(d, v, p, b && tn.has(d) ? { type: !1 } : x, t, P));
+    const A = v.animation;
+    A && h.push(A);
+  }
+  if (o) {
+    const d = () => S.update(() => {
+      o && _r(t, o);
+    });
+    h.length ? Promise.all(h).then(d) : d();
+  }
+  return h;
+}
+function ve(t, e, i = {}) {
+  const s = ut(t, e, i.type === "exit" ? t.presenceContext?.custom : void 0);
+  let { transition: n = t.getDefaultTransition() || {} } = s || {};
+  i.transitionOverride && (n = i.transitionOverride);
+  const r = s ? () => Promise.all(sn(t, s, i)) : () => Promise.resolve(), o = t.variantChildren && t.variantChildren.size ? (l = 0) => {
+    const { delayChildren: u = 0, staggerChildren: c, staggerDirection: h } = n;
+    return Xr(t, e, l, u, c, h, i);
+  } : () => Promise.resolve(), { when: a } = n;
+  if (a) {
+    const [l, u] = a === "beforeChildren" ? [r, o] : [o, r];
+    return l().then(() => u());
+  } else
+    return Promise.all([r(), o(i.delay)]);
+}
+function Xr(t, e, i = 0, s = 0, n = 0, r = 1, o) {
+  const a = [];
+  for (const l of t.variantChildren)
+    l.notify("AnimationStart", e), a.push(ve(l, e, {
+      ...o,
+      delay: i + (typeof s == "function" ? 0 : s) + qs(t.variantChildren, l, s, n, r)
+    }).then(() => l.notify("AnimationComplete", e)));
+  return Promise.all(a);
+}
+function Yr(t, e, i = {}) {
+  t.notify("AnimationStart", e);
+  let s;
+  if (Array.isArray(e)) {
+    const n = e.map((r) => ve(t, r, i));
+    s = Promise.all(n);
+  } else if (typeof e == "string")
+    s = ve(t, e, i);
+  else {
+    const n = typeof e == "function" ? ut(t, e, i.custom) : e;
+    s = Promise.all(sn(t, n, i));
+  }
+  return s.then(() => {
+    t.notify("AnimationComplete", e);
+  });
+}
+const qr = {
+  test: (t) => t === "auto",
+  parse: (t) => t
+}, Zr = (t) => (e) => e.test(t), Jr = [we, Ot, nt, _n, $n, Gn, qr], mi = (t) => Jr.find(Zr(t));
+function Qr(t) {
+  return typeof t == "number" ? t === 0 : t !== null ? t === "none" || t === "0" || Me(t) : !0;
+}
+const ta = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function ea(t, e, i) {
+  let s = 0, n;
+  for (; s < t.length && !n; ) {
+    const r = t[s];
+    typeof r == "string" && !ta.has(r) && mo(r) && (n = t[s]), s++;
+  }
+  if (n && i)
+    for (const r of e)
+      t[r] !== n && (t[r] = Ke(i, n));
+}
+class ia extends _e {
+  constructor(e, i, s, n, r) {
+    super(e, i, s, n, r, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: i, name: s } = this;
+    if (!i || !i.current)
+      return;
+    super.readKeyframes();
+    for (let c = 0; c < e.length; c++) {
+      let h = e[c];
+      if (typeof h == "string" && (h = h.trim(), Ae(h))) {
+        const f = Js(h, i.current);
+        f !== void 0 && (e[c] = f), c === e.length - 1 && (this.finalKeyframe = h);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !tn.has(s) || e.length !== 2)
+      return;
+    const [n, r] = e;
+    if (typeof n == "number" && typeof r == "number")
+      return;
+    const o = mi(n), a = mi(r), l = Ze(n), u = Ze(r);
+    if (l !== u && it[s]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (o !== a)
+      if (li(o) && li(a))
+        for (let c = 0; c < e.length; c++) {
+          const h = e[c];
+          typeof h == "string" && (e[c] = parseFloat(h));
+        }
+      else it[s] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: i } = this, s = [];
+    for (let n = 0; n < e.length; n++)
+      (e[n] === null || Qr(e[n])) && s.push(n);
+    s.length && ea(e, s, i);
+  }
+  measure() {
+    const { element: e, name: i } = this;
+    return it[i](window.getComputedStyle(e.current), () => e.measureViewportBox());
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: i, name: s } = this;
+    if (!e || !e.current)
+      return;
+    s === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = this.measure(), i[0] = this.measuredOrigin;
+    const n = i[i.length - 1];
+    n !== void 0 && this.motionValue?.jump(n, !1);
+  }
+  measureEndState() {
+    const { element: e, unresolvedKeyframes: i } = this;
+    if (!e || !e.current)
+      return;
+    this.motionValue?.jump(this.measuredOrigin, !1);
+    const s = i.length - 1, n = i[s];
+    i[s] = this.measure(), n !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = n), this.removedTransforms?.length && this.removedTransforms.forEach(([r, o]) => {
+      e.getValue(r).set(o);
+    }), this.resolveNoneKeyframes();
+  }
+}
+const We = [
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomRightRadius",
+  "borderBottomLeftRadius"
+];
+function sa(t) {
+  return gs(t) && "offsetHeight" in t && !("ownerSVGElement" in t);
+}
+function nn(t) {
+  return gs(t) && "ownerSVGElement" in t;
+}
+function on(t, e, i) {
+  if (t == null)
+    return [];
+  if (t instanceof EventTarget)
+    return [t];
+  if (typeof t == "string") {
+    let s = document;
+    const n = i?.[t] ?? s.querySelectorAll(t);
+    return n ? Array.from(n) : [];
+  }
+  return Array.from(t).filter((s) => s != null);
+}
+function rn({ top: t, left: e, right: i, bottom: s }) {
+  return {
+    x: { min: e, max: i },
+    y: { min: t, max: s }
+  };
+}
+function na({ x: t, y: e }) {
+  return { top: e.min, right: t.max, bottom: e.max, left: t.min };
+}
+function oa(t, e) {
+  if (!e)
+    return t;
+  const i = e({ x: t.left, y: t.top }), s = e({ x: t.right, y: t.bottom });
+  return {
+    top: i.y,
+    left: i.x,
+    bottom: s.y,
+    right: s.x
+  };
+}
+function zt(t) {
+  return t === void 0 || t === 1;
+}
+function xe({ scale: t, scaleX: e, scaleY: i }) {
+  return !zt(t) || !zt(e) || !zt(i);
+}
+function Q(t) {
+  return xe(t) || an(t) || t.z || t.rotate || t.rotateX || t.rotateY || t.skewX || t.skewY;
+}
+function an(t) {
+  return yi(t.x) || yi(t.y);
+}
+function yi(t) {
+  return t && t !== "0%";
+}
+function It(t, e, i) {
+  const s = t - i, n = e * s;
+  return i + n;
+}
+function gi(t, e, i, s, n) {
+  return n !== void 0 && (t = It(t, n, s)), It(t, i, s) + e;
+}
+function Te(t, e = 0, i = 1, s, n) {
+  t.min = gi(t.min, e, i, s, n), t.max = gi(t.max, e, i, s, n);
+}
+function ln(t, { x: e, y: i }) {
+  Te(t.x, e.translate, e.scale, e.originPoint), Te(t.y, i.translate, i.scale, i.originPoint);
+}
+const vi = 0.999999999999, xi = 1.0000000000001;
+function ra(t, e, i, s = !1) {
+  const n = i.length;
+  if (!n)
+    return;
+  e.x = e.y = 1;
+  let r, o;
+  for (let a = 0; a < n; a++) {
+    r = i[a], o = r.projectionDelta;
+    const { visualElement: l } = r.options;
+    l && l.props.style && l.props.style.display === "contents" || (s && r.options.layoutScroll && r.scroll && r !== r.root && (G(t.x, -r.scroll.offset.x), G(t.y, -r.scroll.offset.y)), o && (e.x *= o.x.scale, e.y *= o.y.scale, ln(t, o)), s && Q(r.latestValues) && Ct(t, r.latestValues, r.layout?.layoutBox));
+  }
+  e.x < xi && e.x > vi && (e.x = 1), e.y < xi && e.y > vi && (e.y = 1);
+}
+function G(t, e) {
+  t.min += e, t.max += e;
+}
+function Ti(t, e, i, s, n = 0.5) {
+  const r = w(t.min, t.max, n);
+  Te(t, e, i, r, s);
+}
+function Pi(t, e) {
+  return typeof t == "string" ? parseFloat(t) / 100 * (e.max - e.min) : t;
+}
+function Ct(t, e, i) {
+  const s = i ?? t;
+  Ti(t.x, Pi(e.x, s.x), e.scaleX, e.scale, e.originX), Ti(t.y, Pi(e.y, s.y), e.scaleY, e.scale, e.originY);
+}
+function cn(t, e) {
+  return rn(oa(t.getBoundingClientRect(), e));
+}
+function aa(t, e, i) {
+  const s = cn(t, i), { scroll: n } = e;
+  return n && (G(s.x, n.offset.x), G(s.y, n.offset.y)), s;
+}
+const { schedule: un } = /* @__PURE__ */ Hn(queueMicrotask, !1), la = {
+  y: !1
+};
+function ca() {
+  return la.y;
+}
+function hn(t, e) {
+  const i = on(t), s = new AbortController(), n = {
+    passive: !0,
+    ...e,
+    signal: s.signal
+  };
+  return [i, n, () => s.abort()];
+}
+function ua(t) {
+  return !(t.pointerType === "touch" || ca());
+}
+function ha(t, e, i = {}) {
+  const [s, n, r] = hn(t, i);
+  return s.forEach((o) => {
+    let a = !1, l = !1, u;
+    const c = () => {
+      o.removeEventListener("pointerleave", d);
+    }, h = (p) => {
+      u && (u(p), u = void 0), c();
+    }, f = (p) => {
+      a = !1, window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", f), l && (l = !1, h(p));
+    }, m = () => {
+      a = !0, window.addEventListener("pointerup", f, n), window.addEventListener("pointercancel", f, n);
+    }, d = (p) => {
+      if (p.pointerType !== "touch") {
+        if (a) {
+          l = !0;
+          return;
+        }
+        h(p);
+      }
+    }, v = (p) => {
+      if (!ua(p))
+        return;
+      l = !1;
+      const x = e(o, p);
+      typeof x == "function" && (u = x, o.addEventListener("pointerleave", d, n));
+    };
+    o.addEventListener("pointerenter", v, n), o.addEventListener("pointerdown", m, n);
+  }), r;
+}
+const fn = (t, e) => e ? t === e ? !0 : fn(t, e.parentElement) : !1, fa = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, da = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function pa(t) {
+  return da.has(t.tagName) || t.isContentEditable === !0;
+}
+const Et = /* @__PURE__ */ new WeakSet();
+function bi(t) {
+  return (e) => {
+    e.key === "Enter" && t(e);
+  };
+}
+function Xt(t, e) {
+  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
+}
+const ma = (t, e) => {
+  const i = t.currentTarget;
+  if (!i)
+    return;
+  const s = bi(() => {
+    if (Et.has(i))
+      return;
+    Xt(i, "down");
+    const n = bi(() => {
+      Xt(i, "up");
+    }), r = () => Xt(i, "cancel");
+    i.addEventListener("keyup", n, e), i.addEventListener("blur", r, e);
+  });
+  i.addEventListener("keydown", s, e), i.addEventListener("blur", () => i.removeEventListener("keydown", s), e);
+};
+function Si(t) {
+  return fa(t) && !0;
+}
+const wi = /* @__PURE__ */ new WeakSet();
+function ya(t, e, i = {}) {
+  const [s, n, r] = hn(t, i), o = (a) => {
+    const l = a.currentTarget;
+    if (!Si(a) || wi.has(a))
+      return;
+    Et.add(l), i.stopPropagation && wi.add(a);
+    const u = e(l, a), c = { ...n, capture: !0 }, h = (d, v) => {
+      window.removeEventListener("pointerup", f, c), window.removeEventListener("pointercancel", m, c), Et.has(l) && Et.delete(l), Si(d) && typeof u == "function" && u(d, { success: v });
+    }, f = (d) => {
+      h(d, l === window || l === document || i.useGlobalTarget || fn(l, d.target));
+    }, m = (d) => {
+      h(d, !1);
+    };
+    window.addEventListener("pointerup", f, c), window.addEventListener("pointercancel", m, c);
+  };
+  return s.forEach((a) => {
+    (i.useGlobalTarget ? window : a).addEventListener("pointerdown", o, n), sa(a) && (a.addEventListener("focus", (u) => ma(u, n)), !pa(a) && !a.hasAttribute("tabindex") && (a.tabIndex = 0));
+  }), r;
+}
+function ga(t) {
+  return nn(t) && t.tagName === "svg";
+}
+const Ai = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), lt = () => ({
+  x: Ai(),
+  y: Ai()
+}), Vi = () => ({ min: 0, max: 0 }), E = () => ({
+  x: Vi(),
+  y: Vi()
+}), va = /* @__PURE__ */ new WeakMap();
+function ze(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+const xa = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], Di = ["initial", ...xa];
+function dn(t) {
+  if (ze(t.animate))
+    return !0;
+  for (let e = 0; e < Di.length; e++)
+    if (De(t[Di[e]]))
+      return !0;
+  return !1;
+}
+function Ta(t) {
+  return !!(dn(t) || t.variants);
+}
+function Pa(t, e, i) {
+  for (const s in e) {
+    const n = e[s], r = i[s];
+    if (I(n))
+      t.addValue(s, n);
+    else if (I(r))
+      t.addValue(s, ht(n, { owner: t }));
+    else if (r !== n)
+      if (t.hasValue(s)) {
+        const o = t.getValue(s);
+        o.liveStyle === !0 ? o.jump(n) : o.hasAnimated || o.set(n);
+      } else {
+        const o = t.getStaticValue(s);
+        t.addValue(s, ht(o !== void 0 ? o : n, { owner: t }));
+      }
+  }
+  for (const s in i)
+    e[s] === void 0 && t.removeValue(s);
+  return e;
+}
+const Pe = { current: null }, pn = { current: !1 }, ba = typeof window < "u";
+function Sa() {
+  if (pn.current = !0, !!ba)
+    if (window.matchMedia) {
+      const t = window.matchMedia("(prefers-reduced-motion)"), e = () => Pe.current = t.matches;
+      t.addEventListener("change", e), e();
+    } else
+      Pe.current = !1;
+}
+const Ci = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+let Ei = {};
+class wa {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(e, i, s) {
+    return {};
+  }
+  constructor({ parent: e, props: i, presenceContext: s, reducedMotionConfig: n, skipAnimations: r, blockInitialAnimation: o, visualState: a }, l = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.shouldSkipAnimations = !1, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = _e, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.hasBeenMounted = !1, 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 m = B.now();
+      this.renderScheduledAt < m && (this.renderScheduledAt = m, S.render(this.render, !1, !0));
+    };
+    const { latestValues: u, renderState: c } = a;
+    this.latestValues = u, this.baseTarget = { ...u }, this.initialValues = i.initial ? { ...u } : {}, this.renderState = c, this.parent = e, this.props = i, this.presenceContext = s, this.depth = e ? e.depth + 1 : 0, this.reducedMotionConfig = n, this.skipAnimationsConfig = r, this.options = l, this.blockInitialAnimation = !!o, this.isControllingVariants = dn(i), this.isVariantNode = Ta(i), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(e && e.current);
+    const { willChange: h, ...f } = this.scrapeMotionValuesFromProps(i, {}, this);
+    for (const m in f) {
+      const d = f[m];
+      u[m] !== void 0 && I(d) && d.set(u[m]);
+    }
+  }
+  mount(e) {
+    if (this.hasBeenMounted)
+      for (const i in this.initialValues)
+        this.values.get(i)?.jump(this.initialValues[i]), this.latestValues[i] = this.initialValues[i];
+    this.current = e, va.set(e, this), this.projection && !this.projection.instance && this.projection.mount(e), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((i, s) => this.bindToMotionValue(s, i)), this.reducedMotionConfig === "never" ? this.shouldReduceMotion = !1 : this.reducedMotionConfig === "always" ? this.shouldReduceMotion = !0 : (pn.current || Sa(), this.shouldReduceMotion = Pe.current), this.shouldSkipAnimations = this.skipAnimationsConfig ?? !1, this.parent?.addChild(this), this.update(this.props, this.presenceContext), this.hasBeenMounted = !0;
+  }
+  unmount() {
+    this.projection && this.projection.unmount(), q(this.notifyUpdate), q(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent?.removeChild(this);
+    for (const e in this.events)
+      this.events[e].clear();
+    for (const e in this.features) {
+      const i = this.features[e];
+      i && (i.unmount(), i.isMounted = !1);
+    }
+    this.current = null;
+  }
+  addChild(e) {
+    this.children.add(e), this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set()), this.enteringChildren.add(e);
+  }
+  removeChild(e) {
+    this.children.delete(e), this.enteringChildren && this.enteringChildren.delete(e);
+  }
+  bindToMotionValue(e, i) {
+    if (this.valueSubscriptions.has(e) && this.valueSubscriptions.get(e)(), i.accelerate && ye.has(e) && this.current instanceof HTMLElement) {
+      const { factory: o, keyframes: a, times: l, ease: u, duration: c } = i.accelerate, h = new Xs({
+        element: this.current,
+        name: e,
+        keyframes: a,
+        times: l,
+        ease: u,
+        duration: /* @__PURE__ */ K(c)
+      }), f = o(h);
+      this.valueSubscriptions.set(e, () => {
+        f(), h.cancel();
+      });
+      return;
+    }
+    const s = bt.has(e);
+    s && this.onBindTransform && this.onBindTransform();
+    const n = i.on("change", (o) => {
+      this.latestValues[e] = o, this.props.onUpdate && S.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender();
+    });
+    let r;
+    typeof window < "u" && window.MotionCheckAppearSync && (r = window.MotionCheckAppearSync(this, e, i)), this.valueSubscriptions.set(e, () => {
+      n(), r && r();
+    });
+  }
+  sortNodePosition(e) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== e.type ? 0 : this.sortInstanceNodePosition(this.current, e.current);
+  }
+  updateFeatures() {
+    let e = "animation";
+    for (e in Ei) {
+      const i = Ei[e];
+      if (!i)
+        continue;
+      const { isEnabled: s, Feature: n } = i;
+      if (!this.features[e] && n && s(this.props) && (this.features[e] = new n(this)), this.features[e]) {
+        const r = this.features[e];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : E();
+  }
+  getStaticValue(e) {
+    return this.latestValues[e];
+  }
+  setStaticValue(e, i) {
+    this.latestValues[e] = i;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(e, i) {
+    (e.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = e, this.prevPresenceContext = this.presenceContext, this.presenceContext = i;
+    for (let s = 0; s < Ci.length; s++) {
+      const n = Ci[s];
+      this.propEventSubscriptions[n] && (this.propEventSubscriptions[n](), delete this.propEventSubscriptions[n]);
+      const r = "on" + n, o = e[r];
+      o && (this.propEventSubscriptions[n] = this.on(n, o));
+    }
+    this.prevMotionValues = Pa(this, this.scrapeMotionValuesFromProps(e, this.prevProps || {}, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(e) {
+    return this.props.variants ? this.props.variants[e] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(e) {
+    const i = this.getClosestVariantNode();
+    if (i)
+      return i.variantChildren && i.variantChildren.add(e), () => i.variantChildren.delete(e);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(e, i) {
+    const s = this.values.get(e);
+    i !== s && (s && this.removeValue(e), this.bindToMotionValue(e, i), this.values.set(e, i), this.latestValues[e] = i.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(e) {
+    this.values.delete(e);
+    const i = this.valueSubscriptions.get(e);
+    i && (i(), this.valueSubscriptions.delete(e)), delete this.latestValues[e], this.removeValueFromRenderState(e, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(e) {
+    return this.values.has(e);
+  }
+  getValue(e, i) {
+    if (this.props.values && this.props.values[e])
+      return this.props.values[e];
+    let s = this.values.get(e);
+    return s === void 0 && i !== void 0 && (s = ht(i === null ? void 0 : i, { owner: this }), this.addValue(e, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(e, i) {
+    let s = this.latestValues[e] !== void 0 || !this.current ? this.latestValues[e] : this.getBaseTargetFromProps(this.props, e) ?? this.readValueFromInstance(this.current, e, this.options);
+    return s != null && (typeof s == "string" && (Ee(s) || Me(s)) ? s = parseFloat(s) : (
+      /**
+       * If the value as read isn't animatable (e.g. "none") but
+       * the target is, derive an animatable none from the target.
+       * A value is animatable if it's a number or contains a
+       * number or color, which is cheaper to check than trying
+       * every value type in turn.
+       */
+      typeof s != "number" && !j.test(s) && j.test(i) && (s = Ke(e, i))
+    ), this.setBaseTarget(e, I(s) ? s.get() : s)), I(s) ? s.get() : s;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(e, i) {
+    this.baseTarget[e] = i;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(e) {
+    const { initial: i } = this.props;
+    let s;
+    if (typeof i == "string" || typeof i == "object") {
+      const r = Qs(this.props, i, this.presenceContext?.custom);
+      r && (s = r[e]);
+    }
+    if (i && s !== void 0)
+      return s;
+    const n = this.getBaseTargetFromProps(this.props, e);
+    return n !== void 0 && !I(n) ? n : this.initialValues[e] !== void 0 && s === void 0 ? void 0 : this.baseTarget[e];
+  }
+  on(e, i) {
+    return this.events[e] || (this.events[e] = new Lt()), this.events[e].add(i);
+  }
+  notify(e, ...i) {
+    this.events[e] && this.events[e].notify(...i);
+  }
+  scheduleRenderMicrotask() {
+    un.render(this.render);
+  }
+}
+class mn extends wa {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = ia;
+  }
+  sortInstanceNodePosition(e, i) {
+    return e.compareDocumentPosition(i) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, i) {
+    const s = e.style;
+    return s ? s[i] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: i, style: s }) {
+    delete i[e], delete s[e];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    I(e) && (this.childSubscription = e.on("change", (i) => {
+      this.current && (this.current.textContent = `${i}`);
+    }));
+  }
+}
+function yn(t, { style: e, vars: i }, s, n) {
+  const r = t.style;
+  let o;
+  for (o in e)
+    r[o] = e[o];
+  n?.applyProjectionStyles(r, s);
+  for (o in i)
+    r.setProperty(o, i[o]);
+}
+function Mi(t, e) {
+  return e.max === e.min ? 0 : t / (e.max - e.min) * 100;
+}
+const H = {
+  correct: (t, e) => {
+    if (!e.target)
+      return t;
+    if (typeof t == "string")
+      if (Ot.test(t))
+        t = parseFloat(t);
+      else
+        return t;
+    const i = Mi(t, e.target.x), s = Mi(t, e.target.y);
+    return `${i}% ${s}%`;
+  }
+}, gn = {
+  correct: (t, { treeScale: e, projectionDelta: i }) => {
+    const s = t, n = j.parse(t);
+    if (n.length > 5)
+      return s;
+    const r = j.createTransformer(t), o = typeof n[0] != "number" ? 1 : 0, a = i.x.scale * e.x, l = i.y.scale * e.y;
+    n[0 + o] /= a, n[1 + o] /= l;
+    const u = w(a, l, 0.5);
+    return typeof n[2 + o] == "number" && (n[2 + o] /= u), typeof n[3 + o] == "number" && (n[3 + o] /= u), r(n);
+  }
+}, xt = {
+  borderRadius: {
+    ...H,
+    applyTo: [...We]
+  },
+  borderTopLeftRadius: H,
+  borderTopRightRadius: H,
+  borderBottomLeftRadius: H,
+  borderBottomRightRadius: H,
+  boxShadow: gn
+};
+function vn(t) {
+  for (const e in t)
+    xt[e] = t[e], ps(e) && (xt[e].isCSSVariable = !0);
+}
+function Aa(t, { layout: e, layoutId: i }) {
+  return bt.has(t) || t.startsWith("origin") || (e || i !== void 0) && (!!xt[t] || t === "opacity");
+}
+function xn(t, e, i) {
+  const s = t.style, n = e?.style, r = {};
+  if (!s)
+    return r;
+  for (const o in s)
+    (I(s[o]) || n && I(n[o]) || Aa(o, t) || i?.getValue(o)?.liveStyle !== void 0) && (r[o] = s[o]);
+  return r;
+}
+function Va(t) {
+  return window.getComputedStyle(t);
+}
+class Da extends mn {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = yn;
+  }
+  mount(e) {
+    ot(!!e.style, "motion.create() components must forward their ref to a HTML or SVG element", "custom-component-ref"), super.mount(e);
+  }
+  readValueFromInstance(e, i) {
+    if (bt.has(i))
+      return this.projection?.isProjecting ? ue(i) : sr(e, i);
+    {
+      const s = Va(e), n = (ps(i) ? s.getPropertyValue(i) : s[i]) || 0;
+      return typeof n == "string" ? n.trim() : n;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: i }) {
+    return cn(e, i);
+  }
+  build(e, i, s) {
+    Wn(e, i, s.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, i, s) {
+    return xn(e, i, s);
+  }
+}
+function Ca(t, e, i, s) {
+  yn(t, e, void 0, s);
+  for (const n in e.attrs)
+    t.setAttribute(ms.has(n) ? n : He(n), e.attrs[n]);
+}
+function Ea(t, e, i) {
+  const s = xn(t, e, i);
+  for (const n in t)
+    if (I(t[n]) || I(e[n])) {
+      const r = Ve.indexOf(n) !== -1 ? "attr" + n.charAt(0).toUpperCase() + n.substring(1) : n;
+      s[r] = t[n];
+    }
+  return s;
+}
+class Ma extends mn {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = E;
+  }
+  getBaseTargetFromProps(e, i) {
+    return e[i];
+  }
+  readValueFromInstance(e, i) {
+    if (bt.has(i)) {
+      const s = Us(i);
+      return s && s.default || 0;
+    }
+    if (zn.includes(i)) {
+      const n = getComputedStyle(e)[i];
+      if (typeof n == "string" && n)
+        return n.trim();
+    }
+    return i = ms.has(i) ? i : He(i), e.getAttribute(i);
+  }
+  scrapeMotionValuesFromProps(e, i, s) {
+    return Ea(e, i, s);
+  }
+  build(e, i, s) {
+    Xn(e, i, this.isSVGTag, s.transformTemplate, s.style);
+  }
+  renderInstance(e, i, s, n) {
+    Ca(e, i, s, n);
+  }
+  mount(e) {
+    this.isSVGTag = Yn(e.tagName), super.mount(e);
+  }
+}
+function be(t, e) {
+  t.min = e.min, t.max = e.max;
+}
+function _(t, e) {
+  be(t.x, e.x), be(t.y, e.y);
+}
+function Ri(t, e) {
+  t.translate = e.translate, t.scale = e.scale, t.originPoint = e.originPoint, t.origin = e.origin;
+}
+const Tn = 1e-4, Ra = 1 - Tn, La = 1 + Tn, Pn = 0.01, ka = 0 - Pn, Ba = 0 + Pn;
+function F(t) {
+  return t.max - t.min;
+}
+function Fa(t, e, i) {
+  return Math.abs(t - e) <= i;
+}
+function Li(t, e, i, s = 0.5) {
+  t.origin = s, t.originPoint = w(e.min, e.max, t.origin), t.scale = F(i) / F(e), t.translate = w(i.min, i.max, t.origin) - t.originPoint, (t.scale >= Ra && t.scale <= La || isNaN(t.scale)) && (t.scale = 1), (t.translate >= ka && t.translate <= Ba || isNaN(t.translate)) && (t.translate = 0);
+}
+function mt(t, e, i, s) {
+  Li(t.x, e.x, i.x, s ? s.originX : void 0), Li(t.y, e.y, i.y, s ? s.originY : void 0);
+}
+function ki(t, e, i, s = 0) {
+  const n = s ? w(i.min, i.max, s) : i.min;
+  t.min = n + e.min, t.max = t.min + F(e);
+}
+function Ia(t, e, i, s) {
+  ki(t.x, e.x, i.x, s?.x), ki(t.y, e.y, i.y, s?.y);
+}
+function Bi(t, e, i, s = 0) {
+  const n = s ? w(i.min, i.max, s) : i.min;
+  t.min = e.min - n, t.max = t.min + F(e);
+}
+function jt(t, e, i, s) {
+  Bi(t.x, e.x, i.x, s?.x), Bi(t.y, e.y, i.y, s?.y);
+}
+function Fi(t, e, i, s, n) {
+  return t -= e, t = It(t, 1 / i, s), n !== void 0 && (t = It(t, 1 / n, s)), t;
+}
+function ja(t, e = 0, i = 1, s = 0.5, n, r = t, o = t) {
+  if (nt.test(e) && (e = parseFloat(e), e = w(o.min, o.max, e / 100) - o.min), typeof e != "number")
+    return;
+  let a = w(r.min, r.max, s);
+  t === r && (a -= e), t.min = Fi(t.min, e, i, a, n), t.max = Fi(t.max, e, i, a, n);
+}
+function Ii(t, e, [i, s, n], r, o) {
+  ja(t, e[i], e[s], e[n], e.scale, r, o);
+}
+const Oa = ["x", "scaleX", "originX"], Na = ["y", "scaleY", "originY"];
+function ji(t, e, i, s) {
+  Ii(t.x, e, Oa, i ? i.x : void 0, s ? s.x : void 0), Ii(t.y, e, Na, i ? i.y : void 0, s ? s.y : void 0);
+}
+function Oi(t) {
+  return t.translate === 0 && t.scale === 1;
+}
+function bn(t) {
+  return Oi(t.x) && Oi(t.y);
+}
+function Ni(t, e) {
+  return t.min === e.min && t.max === e.max;
+}
+function Ua(t, e) {
+  return Ni(t.x, e.x) && Ni(t.y, e.y);
+}
+function Ui(t, e) {
+  return Math.round(t.min) === Math.round(e.min) && Math.round(t.max) === Math.round(e.max);
+}
+function Sn(t, e) {
+  return Ui(t.x, e.x) && Ui(t.y, e.y);
+}
+function Ki(t) {
+  return F(t.x) / F(t.y);
+}
+function _i(t, e) {
+  return t.translate === e.translate && t.scale === e.scale && t.originPoint === e.originPoint;
+}
+function $(t) {
+  return [t("x"), t("y")];
+}
+function Ka(t, e, i) {
+  let s = "";
+  const n = t.x.translate / e.x, r = t.y.translate / e.y, o = i?.z || 0;
+  if ((n || r || o) && (s = `translate3d(${n}px, ${r}px, ${o}px) `), (e.x !== 1 || e.y !== 1) && (s += `scale(${1 / e.x}, ${1 / e.y}) `), i) {
+    const { transformPerspective: u, rotate: c, pathRotation: h, rotateX: f, rotateY: m, skewX: d, skewY: v } = i;
+    u && (s = `perspective(${u}px) ${s}`), c && (s += `rotate(${c}deg) `), h && (s += `rotate(${h}deg) `), f && (s += `rotateX(${f}deg) `), m && (s += `rotateY(${m}deg) `), d && (s += `skewX(${d}deg) `), v && (s += `skewY(${v}deg) `);
+  }
+  const a = t.x.scale * e.x, l = t.y.scale * e.y;
+  return (a !== 1 || l !== 1) && (s += `scale(${a}, ${l})`), s || "none";
+}
+const _a = We.length, $i = (t) => typeof t == "string" ? parseFloat(t) : t, Gi = (t) => typeof t == "number" || Ot.test(t);
+function $a(t, e, i, s, n, r) {
+  n ? (t.opacity = w(0, i.opacity ?? 1, Ga(s)), t.opacityExit = w(e.opacity ?? 1, 0, Ha(s))) : r && (t.opacity = w(e.opacity ?? 1, i.opacity ?? 1, s));
+  for (let o = 0; o < _a; o++) {
+    const a = We[o];
+    let l = Hi(e, a), u = Hi(i, a);
+    if (l === void 0 && u === void 0)
+      continue;
+    l || (l = 0), u || (u = 0), l === 0 || u === 0 || Gi(l) === Gi(u) ? (t[a] = Math.max(w($i(l), $i(u), s), 0), (nt.test(u) || nt.test(l)) && (t[a] += "%")) : t[a] = u;
+  }
+  (e.rotate || i.rotate) && (t.rotate = w(e.rotate || 0, i.rotate || 0, s));
+}
+function Hi(t, e) {
+  return t[e] !== void 0 ? t[e] : t.borderRadius;
+}
+const Ga = /* @__PURE__ */ wn(0, 0.5, Vs), Ha = /* @__PURE__ */ wn(0.5, 0.95, W);
+function wn(t, e, i) {
+  return (s) => s < t ? 0 : s > e ? 1 : i(/* @__PURE__ */ gt(t, e, s));
+}
+function Wa(t, e, i) {
+  const s = I(t) ? t : ht(t);
+  return s.start(Ge("", s, e, i)), s.animation;
+}
+function Tt(t, e, i, s = { passive: !0 }) {
+  return t.addEventListener(e, i, s), () => t.removeEventListener(e, i, s);
+}
+const za = (t, e) => t.depth - e.depth;
+class Xa {
+  constructor() {
+    this.children = [], this.isDirty = !1;
+  }
+  add(e) {
+    Ce(this.children, e), this.isDirty = !0;
+  }
+  remove(e) {
+    Rt(this.children, e), this.isDirty = !0;
+  }
+  forEach(e) {
+    this.isDirty && this.children.sort(za), this.isDirty = !1, this.children.forEach(e);
+  }
+}
+function Ya(t, e) {
+  const i = B.now(), s = ({ timestamp: n }) => {
+    const r = n - i;
+    r >= e && (q(s), t(r - e));
+  };
+  return S.setup(s, !0), () => q(s);
+}
+function Yt(t) {
+  return I(t) ? t.get() : t;
+}
+class qa {
+  constructor() {
+    this.members = [];
+  }
+  add(e) {
+    Ce(this.members, e);
+    for (let i = this.members.length - 1; i >= 0; i--) {
+      const s = this.members[i];
+      if (s === e || s === this.lead || s === this.prevLead)
+        continue;
+      const n = s.instance;
+      (!n || n.isConnected === !1) && !s.snapshot && (Rt(this.members, s), s.unmount());
+    }
+    e.scheduleRender();
+  }
+  remove(e) {
+    if (Rt(this.members, e), e === this.prevLead && (this.prevLead = void 0), e === this.lead) {
+      const i = this.members[this.members.length - 1];
+      i && this.promote(i);
+    }
+  }
+  relegate(e) {
+    for (let i = this.members.indexOf(e) - 1; i >= 0; i--) {
+      const s = this.members[i];
+      if (s.isPresent !== !1 && s.instance?.isConnected !== !1)
+        return this.promote(s), !0;
+    }
+    return !1;
+  }
+  promote(e, i) {
+    const s = this.lead;
+    if (e !== s && (this.prevLead = s, this.lead = e, e.show(), s)) {
+      s.updateSnapshot(), e.scheduleRender();
+      const { layoutDependency: n } = s.options, { layoutDependency: r } = e.options;
+      (n === void 0 || n !== r) && (e.resumeFrom = s, i && (s.preserveOpacity = !0), s.snapshot && (e.snapshot = s.snapshot, e.snapshot.latestValues = s.animationValues || s.latestValues), e.root?.isUpdating && (e.isLayoutDirty = !0)), e.options.crossfade === !1 && s.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((e) => {
+      e.options.onExitComplete?.(), e.resumingFrom?.options.onExitComplete?.();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((e) => e.instance && e.scheduleRender(!1));
+  }
+  removeLeadSnapshot() {
+    this.lead?.snapshot && (this.lead.snapshot = void 0);
+  }
+}
+const Mt = {
+  /**
+   * Global flag as to whether the tree has animated since the last time
+   * we resized the window
+   */
+  hasAnimatedSinceResize: !0,
+  /**
+   * We set this to true once, on the first update. Any nodes added to the tree beyond that
+   * update will be given a `data-projection-id` attribute.
+   */
+  hasEverUpdated: !1
+}, qt = ["", "X", "Y", "Z"], Za = 1e3;
+let Ja = 0;
+function Zt(t, e, i, s) {
+  const { latestValues: n } = e;
+  n[t] && (i[t] = n[t], e.setStaticValue(t, 0), s && (s[t] = 0));
+}
+function An(t) {
+  if (t.hasCheckedOptimisedAppear = !0, t.root === t)
+    return;
+  const { visualElement: e } = t.options;
+  if (!e)
+    return;
+  const i = en(e);
+  if (window.MotionHasOptimisedAnimation(i, "transform")) {
+    const { layout: n, layoutId: r } = t.options;
+    window.MotionCancelOptimisedAnimation(i, "transform", S, !(n || r));
+  }
+  const { parent: s } = t;
+  s && !s.hasCheckedOptimisedAppear && An(s);
+}
+function Vn({ attachResizeListener: t, defaultParent: e, measureScroll: i, checkIsScrollRoot: s, resetTransform: n }) {
+  return class {
+    constructor(o = {}, a = e?.()) {
+      this.id = Ja++, this.animationId = 0, this.animationCommitId = 0, this.children = /* @__PURE__ */ new Set(), this.options = {}, this.isTreeAnimating = !1, this.isAnimationBlocked = !1, this.isLayoutDirty = !1, this.isProjectionDirty = !1, this.isSharedProjectionDirty = !1, this.isTransformDirty = !1, this.updateManuallyBlocked = !1, this.updateBlockedByResize = !1, this.isUpdating = !1, this.isSVG = !1, this.needsReset = !1, this.shouldResetTransform = !1, this.hasCheckedOptimisedAppear = !1, this.treeScale = { x: 1, y: 1 }, this.eventHandlers = /* @__PURE__ */ new Map(), this.hasTreeAnimated = !1, this.updateScheduled = !1, this.scheduleUpdate = () => this.update(), this.projectionUpdateScheduled = !1, this.checkUpdateFailed = () => {
+        this.isUpdating && (this.isUpdating = !1, this.clearAllSnapshots());
+      }, this.updateProjection = () => {
+        this.projectionUpdateScheduled = !1, this.nodes.forEach(el), this.nodes.forEach(ll), this.nodes.forEach(cl), this.nodes.forEach(il);
+      }, this.resolvedRelativeTargetAt = 0, this.hasProjected = !1, this.isVisible = !0, this.animationProgress = 0, this.sharedNodes = /* @__PURE__ */ new Map(), this.latestValues = o, this.root = a ? a.root || a : this, this.path = a ? [...a.path, a] : [], this.parent = a, this.depth = a ? a.depth + 1 : 0;
+      for (let l = 0; l < this.path.length; l++)
+        this.path[l].shouldResetTransform = !0;
+      this.root === this && (this.nodes = new Xa());
+    }
+    addEventListener(o, a) {
+      return this.eventHandlers.has(o) || this.eventHandlers.set(o, new Lt()), this.eventHandlers.get(o).add(a);
+    }
+    notifyListeners(o, ...a) {
+      const l = this.eventHandlers.get(o);
+      l && l.notify(...a);
+    }
+    hasListeners(o) {
+      return this.eventHandlers.has(o);
+    }
+    /**
+     * Lifecycles
+     */
+    mount(o) {
+      if (this.instance)
+        return;
+      this.isSVG = nn(o) && !ga(o), this.instance = o;
+      const { layoutId: a, layout: l, visualElement: u } = this.options;
+      if (u && !u.current && u.mount(o), this.root.nodes.add(this), this.parent && this.parent.children.add(this), this.root.hasTreeAnimated && (l || a) && (this.isLayoutDirty = !0), t) {
+        let c, h = 0;
+        const f = () => this.root.updateBlockedByResize = !1;
+        S.read(() => {
+          h = window.innerWidth;
+        }), t(o, () => {
+          const m = window.innerWidth;
+          m !== h && (h = m, this.root.updateBlockedByResize = !0, c && c(), c = Ya(f, 250), Mt.hasAnimatedSinceResize && (Mt.hasAnimatedSinceResize = !1, this.nodes.forEach(Xi)));
+        });
+      }
+      a && this.root.registerSharedNode(a, this), this.options.animate !== !1 && u && (a || l) && this.addEventListener("didUpdate", ({ delta: c, hasLayoutChanged: h, hasRelativeLayoutChanged: f, layout: m }) => {
+        if (this.isTreeAnimationBlocked()) {
+          this.target = void 0, this.relativeTarget = void 0;
+          return;
+        }
+        const d = this.options.transition || u.getDefaultTransition() || pl, { onLayoutAnimationStart: v, onLayoutAnimationComplete: p } = u.getProps(), x = !this.targetLayout || !Sn(this.targetLayout, m), T = !h && f;
+        if (this.options.layoutRoot || this.resumeFrom || T || h && (x || !this.currentAnimation)) {
+          this.resumeFrom && (this.resumingFrom = this.resumeFrom, this.resumingFrom.resumingFrom = void 0);
+          const P = {
+            ...$e(d, "layout"),
+            onPlay: v,
+            onComplete: p
+          };
+          (u.shouldReduceMotion || this.options.layoutRoot) && (P.delay = 0, P.type = !1), this.startAnimation(P), this.setAnimationOrigin(c, T, P.path);
+        } else
+          h || Xi(this), this.isLead() && this.options.onExitComplete && this.options.onExitComplete();
+        this.targetLayout = m;
+      });
+    }
+    unmount() {
+      this.options.layoutId && this.willUpdate(), this.root.nodes.remove(this);
+      const o = this.getStack();
+      o && o.remove(this), this.parent && this.parent.children.delete(this), this.instance = void 0, this.eventHandlers.clear(), q(this.updateProjection);
+    }
+    // only on the root
+    blockUpdate() {
+      this.updateManuallyBlocked = !0;
+    }
+    unblockUpdate() {
+      this.updateManuallyBlocked = !1;
+    }
+    isUpdateBlocked() {
+      return this.updateManuallyBlocked || this.updateBlockedByResize;
+    }
+    isTreeAnimationBlocked() {
+      return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || !1;
+    }
+    // Note: currently only running on root node
+    startUpdate() {
+      this.isUpdateBlocked() || (this.isUpdating = !0, this.nodes && this.nodes.forEach(ul), this.animationId++);
+    }
+    getTransformTemplate() {
+      const { visualElement: o } = this.options;
+      return o && o.getProps().transformTemplate;
+    }
+    willUpdate(o = !0) {
+      if (this.root.hasTreeAnimated = !0, this.root.isUpdateBlocked()) {
+        this.options.onExitComplete && this.options.onExitComplete();
+        return;
+      }
+      if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear && An(this), !this.root.isUpdating && this.root.startUpdate(), this.isLayoutDirty)
+        return;
+      this.isLayoutDirty = !0;
+      for (let c = 0; c < this.path.length; c++) {
+        const h = this.path[c];
+        h.shouldResetTransform = !0, (typeof h.latestValues.x == "string" || typeof h.latestValues.y == "string") && (h.isLayoutDirty = !0), h.updateScroll("snapshot"), h.options.layoutRoot && h.willUpdate(!1);
+      }
+      const { layoutId: a, layout: l } = this.options;
+      if (a === void 0 && !l)
+        return;
+      const u = this.getTransformTemplate();
+      this.prevTransformTemplateValue = u ? u(this.latestValues, "") : void 0, this.updateSnapshot(), o && this.notifyListeners("willUpdate");
+    }
+    update() {
+      if (this.updateScheduled = !1, this.isUpdateBlocked()) {
+        const l = this.updateBlockedByResize;
+        this.unblockUpdate(), this.updateBlockedByResize = !1, this.clearAllSnapshots(), l && this.nodes.forEach(nl), this.nodes.forEach(Wi);
+        return;
+      }
+      if (this.animationId <= this.animationCommitId) {
+        this.nodes.forEach(zi);
+        return;
+      }
+      this.animationCommitId = this.animationId, this.isUpdating ? (this.isUpdating = !1, this.nodes.forEach(ol), this.nodes.forEach(rl), this.nodes.forEach(al), this.nodes.forEach(Qa), this.nodes.forEach(tl)) : this.nodes.forEach(zi), this.clearAllSnapshots();
+      const a = B.now();
+      M.delta = z(0, 1e3 / 60, a - M.timestamp), M.timestamp = a, M.isProcessing = !0, Ut.update.process(M), Ut.preRender.process(M), Ut.render.process(M), M.isProcessing = !1;
+    }
+    didUpdate() {
+      this.updateScheduled || (this.updateScheduled = !0, un.read(this.scheduleUpdate));
+    }
+    clearAllSnapshots() {
+      this.nodes.forEach(sl), this.sharedNodes.forEach(hl);
+    }
+    scheduleUpdateProjection() {
+      this.projectionUpdateScheduled || (this.projectionUpdateScheduled = !0, S.preRender(this.updateProjection, !1, !0));
+    }
+    scheduleCheckAfterUnmount() {
+      S.postRender(() => {
+        this.isLayoutDirty ? this.root.didUpdate() : this.root.checkUpdateFailed();
+      });
+    }
+    /**
+     * Update measurements
+     */
+    updateSnapshot() {
+      this.snapshot || !this.instance || (this.snapshot = this.measure(), this.snapshot && !F(this.snapshot.measuredBox.x) && !F(this.snapshot.measuredBox.y) && (this.snapshot = void 0));
+    }
+    updateLayout() {
+      if (!this.instance || (this.updateScroll(), !(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty))
+        return;
+      if (this.resumeFrom && !this.resumeFrom.instance)
+        for (let l = 0; l < this.path.length; l++)
+          this.path[l].updateScroll();
+      const o = this.layout;
+      this.layout = this.measure(!1), this.layoutCorrected || (this.layoutCorrected = E()), this.isLayoutDirty = !1, this.projectionDelta = void 0, this.notifyListeners("measure", this.layout.layoutBox);
+      const { visualElement: a } = this.options;
+      a && a.notify("LayoutMeasure", this.layout.layoutBox, o ? o.layoutBox : void 0);
+    }
+    updateScroll(o = "measure") {
+      let a = !!(this.options.layoutScroll && this.instance);
+      if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === o && (a = !1), a && this.instance) {
+        const l = s(this.instance);
+        this.scroll = {
+          animationId: this.root.animationId,
+          phase: o,
+          isRoot: l,
+          offset: i(this.instance),
+          wasRoot: this.scroll ? this.scroll.isRoot : l
+        };
+      }
+    }
+    resetTransform() {
+      if (!n)
+        return;
+      const o = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout, a = this.projectionDelta && !bn(this.projectionDelta), l = this.getTransformTemplate(), u = l ? l(this.latestValues, "") : void 0, c = u !== this.prevTransformTemplateValue;
+      o && this.instance && (a || Q(this.latestValues) || c) && (n(this.instance, u), this.shouldResetTransform = !1, this.scheduleRender());
+    }
+    measure(o = !0) {
+      const a = this.measurePageBox();
+      let l = this.removeElementScroll(a);
+      return o && (l = this.removeTransform(l)), ml(l), {
+        animationId: this.root.animationId,
+        measuredBox: a,
+        layoutBox: l,
+        latestValues: {},
+        source: this.id
+      };
+    }
+    measurePageBox() {
+      const { visualElement: o } = this.options;
+      if (!o)
+        return E();
+      const a = o.measureViewportBox();
+      if (!(this.scroll?.wasRoot || this.path.some(yl))) {
+        const { scroll: u } = this.root;
+        u && (G(a.x, u.offset.x), G(a.y, u.offset.y));
+      }
+      return a;
+    }
+    removeElementScroll(o) {
+      const a = E();
+      if (_(a, o), this.scroll?.wasRoot)
+        return a;
+      for (let l = 0; l < this.path.length; l++) {
+        const u = this.path[l], { scroll: c, options: h } = u;
+        u !== this.root && c && h.layoutScroll && (c.wasRoot && _(a, o), G(a.x, c.offset.x), G(a.y, c.offset.y));
+      }
+      return a;
+    }
+    applyTransform(o, a = !1, l) {
+      const u = l || E();
+      _(u, o);
+      for (let c = 0; c < this.path.length; c++) {
+        const h = this.path[c];
+        !a && h.options.layoutScroll && h.scroll && h !== h.root && (G(u.x, -h.scroll.offset.x), G(u.y, -h.scroll.offset.y)), Q(h.latestValues) && Ct(u, h.latestValues, h.layout?.layoutBox);
+      }
+      return Q(this.latestValues) && Ct(u, this.latestValues, this.layout?.layoutBox), u;
+    }
+    removeTransform(o) {
+      const a = E();
+      _(a, o);
+      for (let l = 0; l < this.path.length; l++) {
+        const u = this.path[l];
+        if (!Q(u.latestValues))
+          continue;
+        let c;
+        u.instance && (xe(u.latestValues) && u.updateSnapshot(), c = E(), _(c, u.measurePageBox())), ji(a, u.latestValues, u.snapshot?.layoutBox, c);
+      }
+      return Q(this.latestValues) && ji(a, this.latestValues), a;
+    }
+    setTargetDelta(o) {
+      this.targetDelta = o, this.root.scheduleUpdateProjection(), this.isProjectionDirty = !0;
+    }
+    setOptions(o) {
+      this.options = {
+        ...this.options,
+        ...o,
+        crossfade: o.crossfade !== void 0 ? o.crossfade : !0
+      };
+    }
+    clearMeasurements() {
+      this.scroll = void 0, this.layout = void 0, this.snapshot = void 0, this.prevTransformTemplateValue = void 0, this.targetDelta = void 0, this.target = void 0, this.isLayoutDirty = !1;
+    }
+    forceRelativeParentToResolveTarget() {
+      this.relativeParent && this.relativeParent.resolvedRelativeTargetAt !== M.timestamp && this.relativeParent.resolveTargetDelta(!0);
+    }
+    resolveTargetDelta(o = !1) {
+      const a = this.getLead();
+      this.isProjectionDirty || (this.isProjectionDirty = a.isProjectionDirty), this.isTransformDirty || (this.isTransformDirty = a.isTransformDirty), this.isSharedProjectionDirty || (this.isSharedProjectionDirty = a.isSharedProjectionDirty);
+      const l = !!this.resumingFrom || this !== a;
+      if (!(o || l && this.isSharedProjectionDirty || this.isProjectionDirty || this.parent?.isProjectionDirty || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize))
+        return;
+      const { layout: c, layoutId: h } = this.options;
+      if (!this.layout || !(c || h))
+        return;
+      this.resolvedRelativeTargetAt = M.timestamp;
+      const f = this.getClosestProjectingParent();
+      !this.targetDelta && !this.relativeTarget && (this.options.layoutAnchor !== !1 && f && f.layout ? this.createRelativeTarget(f, this.layout.layoutBox, f.layout.layoutBox) : this.removeRelativeTarget()), !(!this.relativeTarget && !this.targetDelta) && (this.target || (this.target = E(), this.targetWithTransforms = E()), this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target ? (this.forceRelativeParentToResolveTarget(), Ia(this.target, this.relativeTarget, this.relativeParent.target, this.options.layoutAnchor || void 0)) : this.targetDelta ? (this.resumingFrom ? this.applyTransform(this.layout.layoutBox, !1, this.target) : _(this.target, this.layout.layoutBox), ln(this.target, this.targetDelta)) : _(this.target, this.layout.layoutBox), this.attemptToResolveRelativeTarget && (this.attemptToResolveRelativeTarget = !1, this.options.layoutAnchor !== !1 && f && !!f.resumingFrom == !!this.resumingFrom && !f.options.layoutScroll && f.target && this.animationProgress !== 1 ? this.createRelativeTarget(f, this.target, f.target) : this.relativeParent = this.relativeTarget = void 0));
+    }
+    getClosestProjectingParent() {
+      if (!(!this.parent || xe(this.parent.latestValues) || an(this.parent.latestValues)))
+        return this.parent.isProjecting() ? this.parent : this.parent.getClosestProjectingParent();
+    }
+    isProjecting() {
+      return !!((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
+    }
+    createRelativeTarget(o, a, l) {
+      this.relativeParent = o, this.forceRelativeParentToResolveTarget(), this.relativeTarget = E(), this.relativeTargetOrigin = E(), jt(this.relativeTargetOrigin, a, l, this.options.layoutAnchor || void 0), _(this.relativeTarget, this.relativeTargetOrigin);
+    }
+    removeRelativeTarget() {
+      this.relativeParent = this.relativeTarget = void 0;
+    }
+    calcProjection() {
+      const o = this.getLead(), a = !!this.resumingFrom || this !== o;
+      let l = !0;
+      if ((this.isProjectionDirty || this.parent?.isProjectionDirty) && (l = !1), a && (this.isSharedProjectionDirty || this.isTransformDirty) && (l = !1), this.resolvedRelativeTargetAt === M.timestamp && (l = !1), l)
+        return;
+      const { layout: u, layoutId: c } = this.options;
+      if (this.isTreeAnimating = !!(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation), this.isTreeAnimating || (this.targetDelta = this.relativeTarget = void 0), !this.layout || !(u || c))
+        return;
+      _(this.layoutCorrected, this.layout.layoutBox);
+      const h = this.treeScale.x, f = this.treeScale.y;
+      ra(this.layoutCorrected, this.treeScale, this.path, a), o.layout && !o.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1) && (o.target = o.layout.layoutBox, o.targetWithTransforms = E());
+      const { target: m } = o;
+      if (!m) {
+        this.prevProjectionDelta && (this.createProjectionDeltas(), this.scheduleRender());
+        return;
+      }
+      !this.projectionDelta || !this.prevProjectionDelta ? this.createProjectionDeltas() : (Ri(this.prevProjectionDelta.x, this.projectionDelta.x), Ri(this.prevProjectionDelta.y, this.projectionDelta.y)), mt(this.projectionDelta, this.layoutCorrected, m, this.latestValues), (this.treeScale.x !== h || this.treeScale.y !== f || !_i(this.projectionDelta.x, this.prevProjectionDelta.x) || !_i(this.projectionDelta.y, this.prevProjectionDelta.y)) && (this.hasProjected = !0, this.scheduleRender(), this.notifyListeners("projectionUpdate", m));
+    }
+    hide() {
+      this.isVisible = !1;
+    }
+    show() {
+      this.isVisible = !0;
+    }
+    scheduleRender(o = !0) {
+      if (this.options.visualElement?.scheduleRender(), o) {
+        const a = this.getStack();
+        a && a.scheduleRender();
+      }
+      this.resumingFrom && !this.resumingFrom.instance && (this.resumingFrom = void 0);
+    }
+    createProjectionDeltas() {
+      this.prevProjectionDelta = lt(), this.projectionDelta = lt(), this.projectionDeltaWithTransform = lt();
+    }
+    setAnimationOrigin(o, a = !1, l) {
+      const u = this.snapshot, c = u ? u.latestValues : {}, h = { ...this.latestValues }, f = lt();
+      (!this.relativeParent || !this.relativeParent.options.layoutRoot) && (this.relativeTarget = this.relativeTargetOrigin = void 0), this.attemptToResolveRelativeTarget = !a;
+      const m = E(), d = u ? u.source : void 0, v = this.layout ? this.layout.source : void 0, p = d !== v, x = this.getStack(), T = !x || x.members.length <= 1, P = !!(p && !T && this.options.crossfade === !0 && !this.path.some(dl));
+      this.animationProgress = 0;
+      let b;
+      const A = l?.interpolateProjection(o);
+      this.mixTargetDelta = (D) => {
+        const y = D / 1e3, g = A?.(y);
+        g ? (f.x.translate = g.x, f.x.scale = w(o.x.scale, 1, y), f.x.origin = o.x.origin, f.x.originPoint = o.x.originPoint, f.y.translate = g.y, f.y.scale = w(o.y.scale, 1, y), f.y.origin = o.y.origin, f.y.originPoint = o.y.originPoint) : (Yi(f.x, o.x, y), Yi(f.y, o.y, y)), this.setTargetDelta(f), this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout && (jt(m, this.layout.layoutBox, this.relativeParent.layout.layoutBox, this.options.layoutAnchor || void 0), fl(this.relativeTarget, this.relativeTargetOrigin, m, y), b && Ua(this.relativeTarget, b) && (this.isProjectionDirty = !1), b || (b = E()), _(b, this.relativeTarget)), p && (this.animationValues = h, $a(h, c, this.latestValues, y, P, T)), g && g.rotate !== void 0 && (this.animationValues || (this.animationValues = h), this.animationValues.pathRotation = g.rotate), this.root.scheduleUpdateProjection(), this.scheduleRender(), this.animationProgress = y;
+      }, this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
+    }
+    startAnimation(o) {
+      this.notifyListeners("animationStart"), this.currentAnimation?.stop(), this.resumingFrom?.currentAnimation?.stop(), this.pendingAnimation && (q(this.pendingAnimation), this.pendingAnimation = void 0), this.pendingAnimation = S.update(() => {
+        Mt.hasAnimatedSinceResize = !0, this.motionValue || (this.motionValue = ht(0)), this.motionValue.jump(0, !1), this.currentAnimation = Wa(this.motionValue, [0, 1e3], {
+          ...o,
+          velocity: 0,
+          isSync: !0,
+          onUpdate: (a) => {
+            this.mixTargetDelta(a), o.onUpdate && o.onUpdate(a);
+          },
+          onComplete: () => {
+            o.onComplete && o.onComplete(), this.completeAnimation();
+          }
+        }), zo(this.currentAnimation, this), this.resumingFrom && (this.resumingFrom.currentAnimation = this.currentAnimation), this.pendingAnimation = void 0;
+      });
+    }
+    completeAnimation() {
+      this.resumingFrom && (this.resumingFrom.currentAnimation = void 0, this.resumingFrom.preserveOpacity = void 0);
+      const o = this.getStack();
+      o && o.exitAnimationComplete(), this.resumingFrom = this.currentAnimation = this.animationValues = void 0, this.notifyListeners("animationComplete");
+    }
+    finishAnimation() {
+      this.currentAnimation && (this.mixTargetDelta && this.mixTargetDelta(Za), this.currentAnimation.stop()), this.completeAnimation();
+    }
+    applyTransformsToTarget() {
+      const o = this.getLead(), { targetWithTransforms: a, layout: l, latestValues: u } = o;
+      let { target: c } = o;
+      if (!(!a || !c || !l)) {
+        if (this !== o && this.layout && l && Dn(this.options.animationType, this.layout.layoutBox, l.layoutBox)) {
+          c = this.target || E();
+          const h = F(this.layout.layoutBox.x);
+          c.x.min = o.target.x.min, c.x.max = c.x.min + h;
+          const f = F(this.layout.layoutBox.y);
+          c.y.min = o.target.y.min, c.y.max = c.y.min + f;
+        }
+        _(a, c), Ct(a, u), mt(this.projectionDeltaWithTransform, this.layoutCorrected, a, u);
+      }
+    }
+    registerSharedNode(o, a) {
+      this.sharedNodes.has(o) || this.sharedNodes.set(o, new qa()), this.sharedNodes.get(o).add(a);
+      const u = a.options.initialPromotionConfig;
+      a.promote({
+        transition: u ? u.transition : void 0,
+        preserveFollowOpacity: u && u.shouldPreserveFollowOpacity ? u.shouldPreserveFollowOpacity(a) : void 0
+      });
+    }
+    isLead() {
+      const o = this.getStack();
+      return o ? o.lead === this : !0;
+    }
+    getLead() {
+      const { layoutId: o } = this.options;
+      return o ? this.getStack()?.lead || this : this;
+    }
+    getPrevLead() {
+      const { layoutId: o } = this.options;
+      return o ? this.getStack()?.prevLead : void 0;
+    }
+    getStack() {
+      const { layoutId: o } = this.options;
+      if (o)
+        return this.root.sharedNodes.get(o);
+    }
+    promote({ needsReset: o, transition: a, preserveFollowOpacity: l } = {}) {
+      const u = this.getStack();
+      u && u.promote(this, l), o && (this.projectionDelta = void 0, this.needsReset = !0), a && this.setOptions({ transition: a });
+    }
+    relegate() {
+      const o = this.getStack();
+      return o ? o.relegate(this) : !1;
+    }
+    resetSkewAndRotation() {
+      const { visualElement: o } = this.options;
+      if (!o)
+        return;
+      let a = !1;
+      const { latestValues: l } = o;
+      if ((l.z || l.rotate || l.rotateX || l.rotateY || l.rotateZ || l.skewX || l.skewY) && (a = !0), !a)
+        return;
+      const u = {};
+      l.z && Zt("z", o, u, this.animationValues);
+      for (let c = 0; c < qt.length; c++)
+        Zt(`rotate${qt[c]}`, o, u, this.animationValues), Zt(`skew${qt[c]}`, o, u, this.animationValues);
+      o.render();
+      for (const c in u)
+        o.setStaticValue(c, u[c]), this.animationValues && (this.animationValues[c] = u[c]);
+      o.scheduleRender();
+    }
+    applyProjectionStyles(o, a) {
+      if (!this.instance || this.isSVG)
+        return;
+      if (!this.isVisible) {
+        o.visibility = "hidden";
+        return;
+      }
+      const l = this.getTransformTemplate();
+      if (this.needsReset) {
+        this.needsReset = !1, o.visibility = "", o.opacity = "", o.pointerEvents = Yt(a?.pointerEvents) || "", o.transform = l ? l(this.latestValues, "") : "none";
+        return;
+      }
+      const u = this.getLead();
+      if (!this.projectionDelta || !this.layout || !u.target) {
+        this.options.layoutId && (o.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1, o.pointerEvents = Yt(a?.pointerEvents) || ""), this.hasProjected && !Q(this.latestValues) && (o.transform = l ? l({}, "") : "none", this.hasProjected = !1);
+        return;
+      }
+      o.visibility = "";
+      const c = u.animationValues || u.latestValues;
+      this.applyTransformsToTarget();
+      let h = Ka(this.projectionDeltaWithTransform, this.treeScale, c);
+      l && (h = l(c, h)), o.transform = h;
+      const { x: f, y: m } = this.projectionDelta;
+      o.transformOrigin = `${f.origin * 100}% ${m.origin * 100}% 0`, u.animationValues ? o.opacity = u === this ? c.opacity ?? this.latestValues.opacity ?? 1 : this.preserveOpacity ? this.latestValues.opacity : c.opacityExit : o.opacity = u === this ? c.opacity !== void 0 ? c.opacity : "" : c.opacityExit !== void 0 ? c.opacityExit : 0;
+      for (const d in xt) {
+        if (c[d] === void 0)
+          continue;
+        const { correct: v, applyTo: p, isCSSVariable: x } = xt[d], T = h === "none" ? c[d] : v(c[d], u);
+        if (p) {
+          const P = p.length;
+          for (let b = 0; b < P; b++)
+            o[p[b]] = T;
+        } else
+          x ? this.options.visualElement.renderState.vars[d] = T : o[d] = T;
+      }
+      this.options.layoutId && (o.pointerEvents = u === this ? Yt(a?.pointerEvents) || "" : "none");
+    }
+    clearSnapshot() {
+      this.resumeFrom = this.snapshot = void 0;
+    }
+    // Only run on root
+    resetTree() {
+      this.root.nodes.forEach((o) => o.currentAnimation?.stop()), this.root.nodes.forEach(Wi), this.root.sharedNodes.clear();
+    }
+  };
+}
+function Qa(t) {
+  t.updateLayout();
+}
+function tl(t) {
+  const e = t.resumeFrom?.snapshot || t.snapshot;
+  if (t.isLead() && t.layout && e && t.hasListeners("didUpdate")) {
+    const { layoutBox: i, measuredBox: s } = t.layout, { animationType: n } = t.options, r = e.source !== t.layout.source;
+    if (n === "size")
+      $((c) => {
+        const h = r ? e.measuredBox[c] : e.layoutBox[c], f = F(h);
+        h.min = i[c].min, h.max = h.min + f;
+      });
+    else if (n === "x" || n === "y") {
+      const c = n === "x" ? "y" : "x";
+      be(r ? e.measuredBox[c] : e.layoutBox[c], i[c]);
+    } else Dn(n, e.layoutBox, i) && $((c) => {
+      const h = r ? e.measuredBox[c] : e.layoutBox[c], f = F(i[c]);
+      h.max = h.min + f, t.relativeTarget && !t.currentAnimation && (t.isProjectionDirty = !0, t.relativeTarget[c].max = t.relativeTarget[c].min + f);
+    });
+    const o = lt();
+    mt(o, i, e.layoutBox);
+    const a = lt();
+    r ? mt(a, t.applyTransform(s, !0), e.measuredBox) : mt(a, i, e.layoutBox);
+    const l = !bn(o);
+    let u = !1;
+    if (!t.resumeFrom) {
+      const c = t.getClosestProjectingParent();
+      if (c && !c.resumeFrom) {
+        const { snapshot: h, layout: f } = c;
+        if (h && f) {
+          const m = t.options.layoutAnchor || void 0, d = E();
+          jt(d, e.layoutBox, h.layoutBox, m);
+          const v = E();
+          jt(v, i, f.layoutBox, m), Sn(d, v) || (u = !0), c.options.layoutRoot && (t.relativeTarget = v, t.relativeTargetOrigin = d, t.relativeParent = c);
+        }
+      }
+    }
+    t.notifyListeners("didUpdate", {
+      layout: i,
+      snapshot: e,
+      delta: a,
+      layoutDelta: o,
+      hasLayoutChanged: l,
+      hasRelativeLayoutChanged: u
+    });
+  } else if (t.isLead()) {
+    const { onExitComplete: i } = t.options;
+    i && i();
+  }
+  t.options.transition = void 0;
+}
+function el(t) {
+  t.parent && (t.isProjecting() || (t.isProjectionDirty = t.parent.isProjectionDirty), t.isSharedProjectionDirty || (t.isSharedProjectionDirty = !!(t.isProjectionDirty || t.parent.isProjectionDirty || t.parent.isSharedProjectionDirty)), t.isTransformDirty || (t.isTransformDirty = t.parent.isTransformDirty));
+}
+function il(t) {
+  t.isProjectionDirty = t.isSharedProjectionDirty = t.isTransformDirty = !1;
+}
+function sl(t) {
+  t.clearSnapshot();
+}
+function Wi(t) {
+  t.clearMeasurements();
+}
+function nl(t) {
+  t.isLayoutDirty = !0, t.updateLayout();
+}
+function zi(t) {
+  t.isLayoutDirty = !1;
+}
+function ol(t) {
+  t.isAnimationBlocked && t.layout && !t.isLayoutDirty && (t.snapshot = t.layout, t.isLayoutDirty = !0);
+}
+function rl(t) {
+  t.relativeTarget && t.relativeParent?.isLayoutDirty && (t.currentAnimation ? t.isLayoutDirty = !0 : (t.targetDelta = void 0, t.removeRelativeTarget()));
+}
+function al(t) {
+  const { visualElement: e } = t.options;
+  e && e.getProps().onBeforeLayoutMeasure && e.notify("BeforeLayoutMeasure"), t.resetTransform();
+}
+function Xi(t) {
+  t.finishAnimation(), t.targetDelta = t.relativeTarget = t.target = void 0, t.isProjectionDirty = !0;
+}
+function ll(t) {
+  t.resolveTargetDelta();
+}
+function cl(t) {
+  t.calcProjection();
+}
+function ul(t) {
+  t.resetSkewAndRotation();
+}
+function hl(t) {
+  t.removeLeadSnapshot();
+}
+function Yi(t, e, i) {
+  t.translate = w(e.translate, 0, i), t.scale = w(e.scale, 1, i), t.origin = e.origin, t.originPoint = e.originPoint;
+}
+function qi(t, e, i, s) {
+  t.min = w(e.min, i.min, s), t.max = w(e.max, i.max, s);
+}
+function fl(t, e, i, s) {
+  qi(t.x, e.x, i.x, s), qi(t.y, e.y, i.y, s);
+}
+function dl(t) {
+  return t.animationValues && t.animationValues.opacityExit !== void 0;
+}
+const pl = {
+  duration: 0.45,
+  ease: [0.4, 0, 0.1, 1]
+}, Zi = (t) => typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(t), Ji = Zi("applewebkit/") && !Zi("chrome/") ? Math.round : W;
+function Qi(t) {
+  t.min = Ji(t.min), t.max = Ji(t.max);
+}
+function ml(t) {
+  Qi(t.x), Qi(t.y);
+}
+function Dn(t, e, i) {
+  return t === "position" || t === "preserve-aspect" && !Fa(Ki(e), Ki(i), 0.2);
+}
+function yl(t) {
+  return t !== t.root && t.scroll?.wasRoot;
+}
+const gl = Vn({
+  attachResizeListener: (t, e) => Tt(t, "resize", e),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body?.scrollLeft || 0,
+    y: document.documentElement.scrollTop || document.body?.scrollTop || 0
+  }),
+  checkIsScrollRoot: () => !0
+}), Jt = {
+  current: void 0
+}, vl = Vn({
+  measureScroll: (t) => ({
+    x: t.scrollLeft,
+    y: t.scrollTop
+  }),
+  defaultParent: () => {
+    if (!Jt.current) {
+      const t = new gl({});
+      t.mount(window), t.setOptions({ layoutScroll: !0 }), Jt.current = t;
+    }
+    return Jt.current;
+  },
+  resetTransform: (t, e) => {
+    t.style.transform = e !== void 0 ? e : "none";
+  },
+  checkIsScrollRoot: (t) => window.getComputedStyle(t).position === "fixed"
+}), xl = {
+  some: 0,
+  all: 1
+};
+function Tl(t, e, { root: i, margin: s, amount: n = "some" } = {}) {
+  const r = on(t), o = /* @__PURE__ */ new WeakMap(), a = (u) => {
+    u.forEach((c) => {
+      const h = o.get(c.target);
+      if (c.isIntersecting !== !!h)
+        if (c.isIntersecting) {
+          const f = e(c.target, c);
+          typeof f == "function" ? o.set(c.target, f) : l.unobserve(c.target);
+        } else typeof h == "function" && (h(c), o.delete(c.target));
+    });
+  }, l = new IntersectionObserver(a, {
+    root: i,
+    rootMargin: s,
+    threshold: typeof n == "number" ? n : xl[n]
+  });
+  return r.forEach((u) => l.observe(u)), () => l.disconnect();
+}
+const ts = (t, e) => Math.abs(t - e);
+function Pl(t, e) {
+  const i = ts(t.x, e.x), s = ts(t.y, e.y);
+  return Math.sqrt(i ** 2 + s ** 2);
+}
+function Cn({ current: t }) {
+  return t ? t.ownerDocument.defaultView : null;
+}
+var X = class {
+  constructor(t) {
+    this.isMount = !1, this.state = t;
+  }
+  mount() {
+  }
+  beforeUnmount() {
+  }
+  unmount() {
+  }
+  update() {
+  }
+  getSnapshot(t) {
+  }
+};
+const En = [
+  "initial",
+  "animate",
+  "exit",
+  "whileHover",
+  "whileDrag",
+  "whileFocus",
+  "whilePress"
+];
+var bl = En.length;
+function Mn(t) {
+  if (!t) return;
+  if (!t.isControllingVariants) {
+    const i = t.parent ? Mn(t.parent) || {} : {};
+    return t.props.initial !== void 0 && (i.initial = t.props.initial), i;
+  }
+  const e = {};
+  for (let i = 0; i < bl; i++) {
+    const s = En[i], n = t.props[s];
+    (De(n) || n === !1) && (e[s] = n);
+  }
+  return e;
+}
+var Rn = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whilePress",
+  "whileDrag",
+  "exit"
+], Sl = [...Rn].reverse(), wl = Rn.length;
+function J(t = !1) {
+  return {
+    isActive: t,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function es() {
+  return {
+    animate: J(!0),
+    whileInView: J(),
+    whileHover: J(),
+    whilePress: J(),
+    whileDrag: J(),
+    whileFocus: J(),
+    exit: J()
+  };
+}
+function Al(t, e) {
+  return typeof e == "string" ? e !== t : Array.isArray(e) ? !ys(e, t) : !1;
+}
+function is(t) {
+  return Array.isArray(t);
+}
+function Vl(t) {
+  return (e) => Promise.all(e.map(({ animation: i, options: s }) => Yr(t, i, s)));
+}
+function Dl(t) {
+  let e = Vl(t), i = es(), s = !0;
+  const n = (l) => (u, c) => {
+    const h = ut(t, c, l === "exit" ? t.presenceContext?.custom : void 0);
+    if (h) {
+      const { transition: f, transitionEnd: m, ...d } = h;
+      u = {
+        ...u,
+        ...d,
+        ...m
+      };
+    }
+    return u;
+  };
+  function r(l) {
+    e = l(t);
+  }
+  function o(l) {
+    const u = t.props, c = Mn(t.parent) || {}, h = [], f = /* @__PURE__ */ new Set();
+    let m = {}, d = 1 / 0;
+    for (let p = 0; p < wl; p++) {
+      const x = Sl[p], T = i[x], P = u[x] !== void 0 ? u[x] : c[x], b = De(P), A = x === l ? T.isActive : null;
+      A === !1 && (d = p);
+      let D = P === c[x] && P !== u[x] && b;
+      if (D && s && t.manuallyAnimateOnMount && (D = !1), T.protectedKeys = { ...m }, !T.isActive && A === null || !P && !T.prevProp || ze(P) || typeof P == "boolean") continue;
+      const y = Al(T.prevProp, P);
+      let g = y || x === l && T.isActive && !D && b || p > d && b, C = !1;
+      const V = Array.isArray(P) ? P : [P];
+      let O = V.reduce(n(x), {});
+      A === !1 && (O = {});
+      const { prevResolvedValues: Xe = {} } = T, Nn = {
+        ...Xe,
+        ...O
+      }, Ye = (k) => {
+        g = !0, f.has(k) && (C = !0, f.delete(k)), T.needsAnimating[k] = !0;
+        const N = t.getValue(k);
+        N && (N.liveStyle = !1);
+      };
+      for (const k in Nn) {
+        const N = O[k], Z = Xe[k];
+        if (Object.hasOwnProperty.call(m, k)) continue;
+        let rt = !1;
+        is(N) && is(Z) ? rt = !ys(N, Z) : rt = N !== Z, rt ? N != null ? Ye(k) : f.add(k) : N !== void 0 && f.has(k) ? Ye(k) : T.protectedKeys[k] = !0;
+      }
+      T.prevProp = P, T.prevResolvedValues = O, T.isActive && (m = {
+        ...m,
+        ...O
+      }), s && t.blockInitialAnimation && (g = !1);
+      const qe = D && y;
+      g && (!qe || C) && h.push(...V.map((k) => {
+        const N = { type: x };
+        if (typeof k == "string" && s && !qe && t.manuallyAnimateOnMount && t.parent) {
+          const { parent: Z } = t, rt = ut(Z, k);
+          if (Z.enteringChildren && rt) {
+            const { delayChildren: Un } = rt.transition || {};
+            N.delay = qs(Z.enteringChildren, t, Un);
+          }
+        }
+        return {
+          animation: k,
+          options: N
+        };
+      }));
+    }
+    if (f.size) {
+      const p = {};
+      if (typeof u.initial != "boolean") {
+        const x = ut(t, Array.isArray(u.initial) ? u.initial[0] : u.initial);
+        x && x.transition && (p.transition = x.transition);
+      }
+      f.forEach((x) => {
+        const T = t.getBaseTarget(x), P = t.getValue(x);
+        P && (P.liveStyle = !0), p[x] = T ?? null;
+      }), h.push({ animation: p });
+    }
+    let v = !!h.length;
+    return s && (u.initial === !1 || u.initial === u.animate) && !t.manuallyAnimateOnMount && (v = !1), s = !1, v ? e(h) : Promise.resolve();
+  }
+  function a(l, u) {
+    if (i[l].isActive === u) return Promise.resolve();
+    t.variantChildren?.forEach((h) => {
+      h.animationState?.setActive(l, u);
+    }), i[l].isActive = u;
+    const c = o(l);
+    for (const h in i) i[h].protectedKeys = {};
+    return c;
+  }
+  return {
+    animateChanges: o,
+    setActive: a,
+    setAnimateFunction: r,
+    getState: () => i,
+    reset: () => {
+      i = es(), s = !0;
+    }
+  };
+}
+function Ln(t) {
+  return t.style.display === "none" || t.offsetParent === null && window.getComputedStyle(t).position !== "fixed";
+}
+var Cl = class extends X {
+  static #t = this.key = "animation";
+  constructor(t) {
+    super(t);
+    const e = t.visualElement;
+    e.animationState ||= Dl(e);
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.state.options;
+    ze(t) && (this.unmountControls = t.subscribe(this.state.visualElement));
+  }
+  mount() {
+    Ln(this.state.element) ? this.state.setActive("exit", !0) : this.state.visualElement.animationState?.animateChanges(), this.updateAnimationControlsSubscription();
+  }
+  update() {
+    this.state.visualElement.animationState?.animateChanges();
+    const { animate: t } = this.state.visualElement.getProps(), { animate: e } = this.state.visualElement.prevProps || {};
+    t !== e && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    this.state.visualElement.animationState.reset(), this.unmountControls?.();
+  }
+}, El = class extends X {
+  constructor(...t) {
+    super(...t), this.exitGeneration = 0;
+  }
+  static #t = this.key = "exit";
+  exit() {
+    const t = ++this.exitGeneration, e = this.state;
+    e.isExiting = !0;
+    const i = new Promise((n) => {
+      this.pendingExit = { resolve: n };
+    }), s = e.visualElement?.animationState?.setActive("exit", !0);
+    return s ? s.then(() => {
+      t === this.exitGeneration && (e.isExiting = !1, e.options?.layoutId ? S.postRender(() => this.tryCompleteExit(t)) : this.tryCompleteExit(t));
+    }) : (e.isExiting = !1, this.tryCompleteExit(t)), e.getSnapshot(!1), i;
+  }
+  reenter() {
+    this.exitGeneration++, this.settleExit(), this.state.isExiting = !1, this.state.setActive("exit", !1), this.state.getSnapshot(!0);
+  }
+  completeExitFromProjection() {
+    this.tryCompleteExit(this.exitGeneration);
+  }
+  tryCompleteExit(t) {
+    t !== this.exitGeneration || this.state.isExiting || this.state.options?.layoutId && this.state.visualElement.projection?.currentAnimation?.state === "running" || this.settleExit();
+  }
+  settleExit() {
+    this.pendingExit?.resolve(), this.pendingExit = void 0;
+  }
+  mount() {
+    this.state.options.presenceContext?.register?.(this.state);
+  }
+  unmount() {
+    this.state.options.presenceContext?.unregister?.(this.state), this.settleExit();
+  }
+};
+function Ml(t, e) {
+  return qn(t) ? new Ma(e) : new Da(e);
+}
+function ss(t) {
+  return { point: {
+    x: t.pageX,
+    y: t.pageY
+  } };
+}
+var Rl = class extends X {
+  static #t = this.key = "press";
+  constructor(t) {
+    super(t);
+  }
+  isActive() {
+    const { whilePress: t, onPress: e, onPressCancel: i, onPressStart: s } = this.state.options;
+    return !!(t || e || i || s);
+  }
+  register() {
+    const t = this.state.element;
+    !t || !this.isActive() || (this.removePress?.(), this.removePress = ya(t, (e, i) => {
+      const s = this.state.options;
+      return this.state.setActive("whilePress", !0), s.onPressStart && S.postRender(() => s.onPressStart(i, ss(i))), (n, { success: r }) => {
+        this.state.setActive("whilePress", !1);
+        const o = r ? "onPress" : "onPressCancel", a = this.state.options[o];
+        a && S.postRender(() => a(n, ss(n)));
+      };
+    }, { useGlobalTarget: this.state.options.globalPressTarget }));
+  }
+  mount() {
+    this.register();
+  }
+  update() {
+    const t = this.state.visualElement.prevProps;
+    !(t?.whilePress || t?.whileTap || t?.onPress || t?.onPressCancel || t?.onPressStart) && this.isActive() && this.register();
+  }
+  unmount() {
+    this.removePress?.(), this.removePress = void 0;
+  }
+};
+function kn(t) {
+  return t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1;
+}
+function Pt(t, e = "page") {
+  return { point: {
+    x: t[`${e}X`],
+    y: t[`${e}Y`]
+  } };
+}
+function Ll(t) {
+  return (e) => kn(e) && t(e, Pt(e));
+}
+var kl = class extends X {
+  static #t = this.key = "hover";
+  constructor(t) {
+    super(t);
+  }
+  isActive() {
+    const { whileHover: t, onHoverStart: e, onHoverEnd: i } = this.state.options;
+    return !!(t || e || i);
+  }
+  register() {
+    const t = this.state.element;
+    !t || !this.isActive() || (this.removeHover?.(), this.removeHover = ha(t, (e, i) => {
+      const s = this.state.options;
+      return this.state.setActive("whileHover", !0), s.onHoverStart && S.postRender(() => s.onHoverStart(i, Pt(i))), (n) => {
+        this.state.setActive("whileHover", !1);
+        const r = this.state.options.onHoverEnd;
+        r && S.postRender(() => r(n, Pt(n)));
+      };
+    }));
+  }
+  mount() {
+    this.register();
+  }
+  update() {
+    const t = this.state.visualElement.prevProps;
+    !(t?.whileHover || t?.onHoverStart || t?.onHoverEnd) && this.isActive() && this.register();
+  }
+  unmount() {
+    this.removeHover?.(), this.removeHover = void 0;
+  }
+}, Bl = class extends X {
+  static #t = this.key = "inView";
+  constructor(t) {
+    super(t);
+  }
+  isActive() {
+    const { whileInView: t, onViewportEnter: e, onViewportLeave: i } = this.state.options;
+    return !!(t || e || i);
+  }
+  startObserver() {
+    const t = this.state.element;
+    if (!t || !this.isActive()) return;
+    this.removeObserver?.();
+    const { once: e, ...i } = this.state.options.inViewOptions || {};
+    this.removeObserver = Tl(t, (s, n) => {
+      const r = this.state.options;
+      if (this.state.setActive("whileInView", !0), r.onViewportEnter && S.postRender(() => r.onViewportEnter(n)), !e) return () => {
+        this.state.setActive("whileInView", !1);
+        const o = this.state.options.onViewportLeave;
+        o && S.postRender(() => o(n));
+      };
+    }, i);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    const { props: t, prevProps: e } = this.state.visualElement;
+    [
+      "amount",
+      "margin",
+      "root"
+    ].some((i) => t.inViewOptions?.[i] !== e?.inViewOptions?.[i]) && this.startObserver();
+  }
+  unmount() {
+    this.removeObserver?.(), this.removeObserver = void 0;
+  }
+}, Fl = class extends X {
+  static #t = this.key = "focus";
+  constructor(t) {
+    super(t), this.isFocused = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.state.element.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    t && (this.state.setActive("whileFocus", !0), this.isFocused = !0);
+  }
+  onBlur() {
+    this.isFocused && (this.state.setActive("whileFocus", !1), this.isFocused = !1);
+  }
+  mount() {
+    const t = this.state.element;
+    this.removeFocus = wt(Tt(t, "focus", () => this.onFocus()), Tt(t, "blur", () => this.onBlur()));
+  }
+  unmount() {
+    this.removeFocus?.(), this.removeFocus = void 0;
+  }
+};
+function Bn(t) {
+  if (t)
+    return t.options.allowProjection !== !1 ? t.projection : Bn(t.parent);
+}
+const Fn = {
+  borderRadius: {
+    ...H,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: H,
+  borderTopRightRadius: H,
+  borderBottomLeftRadius: H,
+  borderBottomRightRadius: H,
+  boxShadow: gn
+};
+function dt(t) {
+  return typeof t == "object" && t !== null && "nodeType" in t;
+}
+const Il = typeof window > "u";
+var jl = class extends X {
+  static #t = this.key = "projection";
+  constructor(t) {
+    super(t), vn(Fn), Il || this.initProjection();
+  }
+  initProjection() {
+    const t = this.state.options;
+    this.state.visualElement.projection = new vl(this.state.visualElement.latestValues, t["data-framer-portal-id"] ? void 0 : Bn(this.state.visualElement.parent)), this.projection = this.state.visualElement.projection, this.projection.isPresent = !0, this.setOptions();
+  }
+  setOptions() {
+    const t = this.state.options, { layoutId: e, layout: i, drag: s = !1, dragConstraints: n = !1 } = t;
+    this.projection?.setOptions({
+      layout: i,
+      layoutId: e,
+      alwaysMeasureLayout: !!e || !!s || n && dt(n),
+      visualElement: this.state.visualElement,
+      animationType: typeof t.layout == "string" ? t.layout : "both",
+      layoutRoot: t.layoutRoot,
+      layoutScroll: t.layoutScroll,
+      crossfade: t.crossfade,
+      onExitComplete: () => {
+        !this.projection?.isPresent && this.state.options.layoutId && !this.state.isExiting && queueMicrotask(() => {
+          this.state.getFeature("exit")?.completeExitFromProjection();
+        });
+      }
+    });
+  }
+  update() {
+    this.setOptions();
+  }
+  mount() {
+    this.projection?.mount(this.state.element);
+  }
+};
+function yt(t, e, i, s) {
+  return Tt(t, e, Ll(i), s);
+}
+var ns = /* @__PURE__ */ new Set(["auto", "scroll"]), In = class {
+  constructor(t, e, { transformPagePoint: i, contextWindow: s, dragSnapToOrigin: n = !1, element: r } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = /* @__PURE__ */ new Map(), this.onElementScroll = (c) => {
+      this.handleScroll(c.target);
+    }, this.onWindowScroll = () => {
+      this.handleScroll(window);
+    }, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+      const c = te(this.lastMoveEventInfo, this.history), h = this.startEvent !== null, f = Pl(c.offset, {
+        x: 0,
+        y: 0
+      }) >= 3;
+      if (!h && !f) return;
+      const { point: m } = c, { timestamp: d } = M;
+      this.history.push({
+        ...m,
+        timestamp: d
+      });
+      const { onStart: v, onMove: p } = this.handlers;
+      h || (v && v(this.lastMoveEvent, c), this.startEvent = this.lastMoveEvent), p && p(this.lastMoveEvent, c);
+    }, this.handlePointerMove = (c, h) => {
+      this.lastMoveEvent = c, this.lastMoveEventInfo = Qt(h, this.transformPagePoint), S.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (c, h) => {
+      this.end();
+      const { onEnd: f, onSessionEnd: m, resumeAnimation: d } = this.handlers;
+      if ((this.dragSnapToOrigin || !this.startEvent) && d && d(), !(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+      const v = te(c.type === "pointercancel" ? this.lastMoveEventInfo : Qt(h, this.transformPagePoint), this.history);
+      this.startEvent && f && f(c, v), m && m(c, v);
+    }, !kn(t)) return;
+    this.dragSnapToOrigin = n, this.handlers = e, this.transformPagePoint = i, this.contextWindow = s || window;
+    const o = Qt(Pt(t), this.transformPagePoint), { point: a } = o, { timestamp: l } = M;
+    this.history = [{
+      ...a,
+      timestamp: l
+    }];
+    const { onSessionStart: u } = e;
+    u && u(t, te(o, this.history)), this.removeListeners = wt(yt(this.contextWindow, "pointermove", this.handlePointerMove), yt(this.contextWindow, "pointerup", this.handlePointerUp), yt(this.contextWindow, "pointercancel", this.handlePointerUp)), r && this.startScrollTracking(r);
+  }
+  isScrollable(t) {
+    const e = window.getComputedStyle(t);
+    return e.overflow === "auto" || e.overflow === "scroll" || e.overflowX === "auto" || e.overflowX === "scroll" || e.overflowY === "auto" || e.overflowY === "scroll";
+  }
+  startScrollTracking(t) {
+    let e = t.parentElement;
+    for (; e; ) {
+      const i = getComputedStyle(e);
+      (ns.has(i.overflowX) || ns.has(i.overflowY)) && this.scrollPositions.set(e, {
+        x: e.scrollLeft,
+        y: e.scrollTop
+      }), e = e.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    }), window.addEventListener("scroll", this.onElementScroll, {
+      capture: !0,
+      passive: !0
+    }), window.addEventListener("scroll", this.onWindowScroll, { passive: !0 }), this.removeScrollListeners = () => {
+      window.removeEventListener("scroll", this.onElementScroll, { capture: !0 }), window.removeEventListener("scroll", this.onWindowScroll);
+    };
+  }
+  handleScroll(t) {
+    const e = this.scrollPositions.get(t);
+    if (!e) return;
+    const i = t === window, s = i ? {
+      x: window.scrollX,
+      y: window.scrollY
+    } : {
+      x: t.scrollLeft,
+      y: t.scrollTop
+    }, n = {
+      x: s.x - e.x,
+      y: s.y - e.y
+    };
+    n.x === 0 && n.y === 0 || (i ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += n.x, this.lastMoveEventInfo.point.y += n.y) : this.history.length > 0 && (this.history[0].x -= n.x, this.history[0].y -= n.y), this.scrollPositions.set(t, s), S.update(this.updatePoint, !0));
+  }
+  updateHandlers(t) {
+    this.handlers = t;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), this.removeScrollListeners?.(), this.scrollPositions.clear(), q(this.updatePoint);
+  }
+};
+function Qt(t, e) {
+  return e ? { point: e(t.point) } : t;
+}
+function os(t, e) {
+  return {
+    x: t.x - e.x,
+    y: t.y - e.y
+  };
+}
+function te({ point: t }, e) {
+  return {
+    point: t,
+    delta: os(t, jn(e)),
+    offset: os(t, Ol(e)),
+    velocity: Nl(e, 0.1)
+  };
+}
+function Ol(t) {
+  return t[0];
+}
+function jn(t) {
+  return t[t.length - 1];
+}
+function Nl(t, e) {
+  if (t.length < 2) return {
+    x: 0,
+    y: 0
+  };
+  let i = t.length - 1, s = null;
+  const n = jn(t);
+  for (; i >= 0 && (s = t[i], !(n.timestamp - s.timestamp > /* @__PURE__ */ K(e))); )
+    i--;
+  if (!s) return {
+    x: 0,
+    y: 0
+  };
+  const r = /* @__PURE__ */ U(n.timestamp - s.timestamp);
+  if (r === 0) return {
+    x: 0,
+    y: 0
+  };
+  const o = {
+    x: (n.x - s.x) / r,
+    y: (n.y - s.y) / r
+  };
+  return o.x === 1 / 0 && (o.x = 0), o.y === 1 / 0 && (o.y = 0), o;
+}
+function rs(t) {
+  return (e, i) => {
+    t && S.postRender(() => t(e, i));
+  };
+}
+var Ul = class extends X {
+  constructor(...t) {
+    super(...t), this.removePointerDownListener = W;
+  }
+  static #t = this.key = "pan";
+  onPointerDown(t) {
+    this.session = new In(t, this.createPanHandlers(), {
+      transformPagePoint: this.state.visualElement.getTransformPagePoint(),
+      contextWindow: Cn(this.state.visualElement)
+    });
+  }
+  createPanHandlers() {
+    return {
+      onSessionStart: rs((t, e) => {
+        const { onPanSessionStart: i } = this.state.options;
+        i && i(t, e);
+      }),
+      onStart: rs((t, e) => {
+        const { onPanStart: i } = this.state.options;
+        i && i(t, e);
+      }),
+      onMove: (t, e) => {
+        const { onPan: i } = this.state.options;
+        i && i(t, e);
+      },
+      onEnd: (t, e) => {
+        const { onPanEnd: i } = this.state.options;
+        delete this.session, i && S.postRender(() => i(t, e));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = yt(this.state.element, "pointerdown", this.onPointerDown.bind(this));
+  }
+  update() {
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+};
+function On(t) {
+  let e = null;
+  return () => {
+    const i = () => {
+      e = null;
+    };
+    return e === null ? (e = t, i) : !1;
+  };
+}
+var as = On("dragHorizontal"), ls = On("dragVertical");
+function Kl(t) {
+  let e = !1;
+  if (t === "y") e = ls();
+  else if (t === "x") e = as();
+  else {
+    const i = as(), s = ls();
+    i && s ? e = () => {
+      i(), s();
+    } : (i && i(), s && s());
+  }
+  return e;
+}
+function _l(t, { min: e, max: i }, s) {
+  return e !== void 0 && t < e ? t = s ? w(e, t, s.min) : Math.max(t, e) : i !== void 0 && t > i && (t = s ? w(i, t, s.max) : Math.min(t, i)), t;
+}
+const Se = 0.35;
+function $l(t, { top: e, left: i, bottom: s, right: n }) {
+  return {
+    x: cs(t.x, i, n),
+    y: cs(t.y, e, s)
+  };
+}
+function cs(t, e, i) {
+  return {
+    min: e !== void 0 ? t.min + e : void 0,
+    max: i !== void 0 ? t.max + i - (t.max - t.min) : void 0
+  };
+}
+function Gl(t = Se) {
+  return t === !1 ? t = 0 : t === !0 && (t = Se), {
+    x: us(t, "left", "right"),
+    y: us(t, "top", "bottom")
+  };
+}
+function us(t, e, i) {
+  return {
+    min: hs(t, e),
+    max: hs(t, i)
+  };
+}
+function hs(t, e) {
+  return typeof t == "number" ? t : t[e] || 0;
+}
+function Hl(t, e) {
+  const i = {};
+  return e.min !== void 0 && (i.min = e.min - t.min), e.max !== void 0 && (i.max = e.max - t.min), i;
+}
+function Wl(t, e) {
+  return {
+    x: fs(t.x, e.x),
+    y: fs(t.y, e.y)
+  };
+}
+function fs(t, e) {
+  let i = e.min - t.min, s = e.max - t.max;
+  return e.max - e.min < t.max - t.min && ([i, s] = [s, i]), {
+    min: i,
+    max: s
+  };
+}
+function zl(t, e) {
+  let i = 0.5;
+  const s = F(t), n = F(e);
+  return n > s ? i = /* @__PURE__ */ gt(e.min, e.max - s, t.min) : s > n && (i = /* @__PURE__ */ gt(t.min, t.max - n, e.min)), z(0, 1, i);
+}
+const Xl = /* @__PURE__ */ new WeakMap();
+var Yl = class {
+  constructor(t) {
+    this.openGlobalLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = {
+      x: 0,
+      y: 0
+    }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = E(), this.state = t;
+  }
+  get visualElement() {
+    return this.state.visualElement;
+  }
+  start(t, { snapToCursor: e = !1 } = {}) {
+    const i = (l) => {
+      e && this.snapToCursor(Pt(l, "page").point), this.stopAnimation();
+    }, s = (l, u) => {
+      this.stopAnimation();
+      const { drag: c, dragPropagation: h, onDragStart: f } = this.getProps();
+      c && !h && (this.openGlobalLock && this.openGlobalLock(), this.openGlobalLock = Kl(c), !this.openGlobalLock) || (this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), $((m) => {
+        let d = this.getAxisMotionValue(m).get() || 0;
+        if (nt.test(d)) {
+          const { projection: v } = this.visualElement;
+          if (v && v.layout) {
+            const p = v.layout.layoutBox[m];
+            p && (d = F(p) * (parseFloat(d) / 100));
+          }
+        }
+        this.originPoint[m] = d;
+      }), f && S.postRender(() => f(l, u)), ge(this.visualElement, "transform"), this.state.setActive("whileDrag", !0));
+    }, n = (l, u) => {
+      const { dragPropagation: c, dragDirectionLock: h, onDirectionLock: f, onDrag: m } = this.getProps();
+      if (!c && !this.openGlobalLock) return;
+      const { offset: d } = u;
+      if (h && this.currentDirection === null) {
+        this.currentDirection = ql(d), this.currentDirection !== null && f && f(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", u.point, d), this.updateAxis("y", u.point, d), this.visualElement.render(), m && m(l, u);
+    }, r = (l, u) => this.stop(l, u), o = () => {
+      const { dragSnapToOrigin: l } = this.getProps();
+      (l || this.constraints) && this.startAnimation({
+        x: 0,
+        y: 0
+      });
+    }, { dragSnapToOrigin: a } = this.getProps();
+    this.panSession = new In(t, {
+      onSessionStart: i,
+      onStart: s,
+      onMove: n,
+      onSessionEnd: r,
+      resumeAnimation: o
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: a,
+      contextWindow: Cn(this.visualElement),
+      element: this.state.element
+    });
+  }
+  stop(t, e) {
+    const i = this.isDragging;
+    if (this.cancel(), !i) return;
+    const { velocity: s } = e;
+    this.startAnimation(s);
+    const { onDragEnd: n } = this.getProps();
+    n && S.postRender(() => n(t, e));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.panSession && this.panSession.end(), this.panSession = void 0;
+    const { dragPropagation: e } = this.getProps();
+    !e && this.openGlobalLock && (this.openGlobalLock(), this.openGlobalLock = null), this.state.setActive("whileDrag", !1);
+  }
+  updateAxis(t, e, i) {
+    const { drag: s } = this.getProps();
+    if (!i || !Vt(t, s, this.currentDirection)) return;
+    const n = this.getAxisMotionValue(t);
+    let r = this.originPoint[t] + i[t];
+    this.constraints && this.constraints[t] && (r = _l(r, this.constraints[t], this.elastic[t])), n.set(r);
+  }
+  resolveConstraints() {
+    const { dragConstraints: t, dragElastic: e } = this.getProps(), i = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection?.layout, s = this.constraints;
+    t && dt(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && i ? this.constraints = $l(i.layoutBox, t) : this.constraints = !1, this.elastic = Gl(e), s !== this.constraints && i && this.constraints && !this.hasMutatedConstraints && $((n) => {
+      this.constraints !== !1 && this.getAxisMotionValue(n) && (this.constraints[n] = Hl(i.layoutBox[n], this.constraints[n]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: e } = this.getProps();
+    if (!t || !dt(t)) return !1;
+    const i = t, { projection: s } = this.visualElement;
+    if (!s || !s.layout) return !1;
+    const n = aa(i, s.root, this.visualElement.getTransformPagePoint());
+    let r = Wl(s.layout.layoutBox, n);
+    if (e) {
+      const o = e(na(r));
+      this.hasMutatedConstraints = !!o, o && (r = rn(o));
+    }
+    return r;
+  }
+  startAnimation(t) {
+    const { drag: e, dragMomentum: i, dragElastic: s, dragTransition: n, dragSnapToOrigin: r, onDragTransitionEnd: o } = this.getProps(), a = this.constraints || {}, l = $((u) => {
+      if (!Vt(u, e, this.currentDirection)) return;
+      let c = a && a[u] || {};
+      r && (c = {
+        min: 0,
+        max: 0
+      });
+      const h = s ? 200 : 1e6, f = s ? 40 : 1e7, m = {
+        type: "inertia",
+        velocity: i ? t[u] : 0,
+        bounceStiffness: h,
+        bounceDamping: f,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...n,
+        ...c
+      };
+      return this.startAxisValueAnimation(u, m);
+    });
+    return Promise.all(l).then(o);
+  }
+  startAxisValueAnimation(t, e) {
+    const i = this.getAxisMotionValue(t);
+    return ge(this.visualElement, t), i.start(Ge(t, i, 0, e, this.visualElement, !1));
+  }
+  stopAnimation() {
+    this.visualElement.projection?.isPresent && $((t) => this.getAxisMotionValue(t).stop());
+  }
+  getAxisMotionValue(t) {
+    const e = `_drag${t.toUpperCase()}`, i = this.visualElement.getProps();
+    return i[e] || this.visualElement.getValue(t, (i.initial ? i.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    $((e) => {
+      const { drag: i } = this.getProps();
+      if (!Vt(e, i, this.currentDirection)) return;
+      const { projection: s } = this.visualElement, n = this.getAxisMotionValue(e);
+      if (s && s.layout) {
+        const { min: r, max: o } = s.layout.layoutBox[e];
+        n.set(t[e] - w(r, o, 0.5));
+      }
+    });
+  }
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current) return;
+    const { drag: t, dragConstraints: e } = this.getProps(), { projection: i } = this.visualElement;
+    if (!dt(e) || !i || !this.constraints) return;
+    this.stopAnimation();
+    const s = {
+      x: 0,
+      y: 0
+    };
+    $((r) => {
+      const o = this.getAxisMotionValue(r);
+      if (o && this.constraints !== !1) {
+        const a = o.get();
+        s[r] = zl({
+          min: a,
+          max: a
+        }, this.constraints[r]);
+      }
+    });
+    const { transformTemplate: n } = this.visualElement.getProps();
+    this.state.element.style.transform = n ? n({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.resolveConstraints(), $((r) => {
+      if (!Vt(r, t, null)) return;
+      const o = this.getAxisMotionValue(r), { min: a, max: l } = this.constraints[r];
+      o.set(w(a, l, s[r]));
+    });
+  }
+  addListeners() {
+    if (!this.state.element) return;
+    Xl.set(this.visualElement, this);
+    const t = this.state.element, e = yt(t, "pointerdown", (a) => {
+      const { drag: l, dragListener: u = !0 } = this.getProps();
+      l && u && this.start(a);
+    }), i = () => {
+      const { dragConstraints: a } = this.getProps();
+      dt(a) && (this.constraints = this.resolveRefConstraints());
+    }, { projection: s } = this.visualElement, n = s.addEventListener("measure", i);
+    s && !s.layout && (s.root && s.root.updateScroll(), s.updateLayout()), S.read(i);
+    const r = Tt(window, "resize", () => this.scalePositionWithinConstraints()), o = s.addEventListener("didUpdate", (({ delta: a, hasLayoutChanged: l }) => {
+      this.isDragging && l && ($((u) => {
+        const c = this.getAxisMotionValue(u);
+        c && (this.originPoint[u] += a[u].translate, c.set(c.get() + a[u].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      r(), e(), n(), o && o();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: e = !1, dragDirectionLock: i = !1, dragPropagation: s = !1, dragConstraints: n = !1, dragElastic: r = Se, dragMomentum: o = !0 } = t;
+    return {
+      ...t,
+      drag: e,
+      dragDirectionLock: i,
+      dragPropagation: s,
+      dragConstraints: n,
+      dragElastic: r,
+      dragMomentum: o
+    };
+  }
+};
+function Vt(t, e, i) {
+  return (e === !0 || e === t) && (i === null || i === t);
+}
+function ql(t, e = 10) {
+  let i = null;
+  return Math.abs(t.y) > e ? i = "y" : Math.abs(t.x) > e && (i = "x"), i;
+}
+var Zl = class extends X {
+  static #t = this.key = "drag";
+  constructor(t) {
+    super(t), this.removeGroupControls = W, this.removeListeners = W, this.controls = new Yl(t);
+  }
+  mount() {
+    const { dragControls: t } = this.state.options;
+    t && (this.removeGroupControls = t.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || W;
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners();
+  }
+}, Jl = class extends X {
+  static #t = this.key = "layout";
+  constructor(t) {
+    super(t), vn(Fn);
+  }
+  updatePrevLead(t) {
+    const e = this.state.visualElement.projection;
+    e.isPresent !== t && (e.isPresent = t, t ? !e.isLead() && e?.promote() : e.isLead() && e?.relegate());
+  }
+  didUpdate() {
+    (this.state.options.layout || this.state.options.layoutId || this.state.options.drag) && this.state.visualElement.projection?.root?.didUpdate();
+  }
+  mount() {
+    const t = this.state.options, e = this.state.options.layoutGroup;
+    if (t.layout || t.layoutId) {
+      const i = this.state.visualElement.projection;
+      if (t.layoutId) {
+        const s = !Ln(this.state.element);
+        i.isPresent = s, s ? i?.promote() : i?.relegate();
+      }
+      e?.group?.add(i), Mt.hasEverUpdated = !0;
+    }
+    this.didUpdate();
+  }
+  unmount() {
+    const t = this.state.options.layoutGroup, e = this.state.visualElement.projection;
+    e && t?.group && (this.state.options.layout || this.state.options.layoutId) && t.group.remove(e);
+  }
+  getSnapshot(t) {
+    const e = this.state.visualElement.projection, { layout: i, layoutId: s, drag: n, layoutDependency: r } = this.state.visualElement.props, o = this.state.visualElement.prevProps;
+    !e || !i && !s && !n || ((n || o.layoutDependency !== r || r === void 0 || t !== e.isPresent) && e.willUpdate(), s && this.updatePrevLead(t), this.didUpdate());
+  }
+  refreshRootScroll() {
+    const t = this.state.visualElement?.projection?.root;
+    t && this.state.options.layoutId && (t.scroll = void 0, t.updateScroll?.());
+  }
+};
+const ec = {
+  renderer: Ml,
+  features: [
+    Cl,
+    El,
+    Rl,
+    kl,
+    Bl,
+    Fl,
+    jl,
+    Ul,
+    Zl,
+    Jl
+  ]
+};
+export {
+  ec as default
+};