https://itcurves.ai/_components/v2/6f7c1cc6f4e6b5f46153147a1b8d898db9975c9c.js

440 Array.isArray(t) && typeof t[0] != "number", ps = (t) => Array.isArray(t) && typeof t[0] == "number", Y9 = {
441  linear: Ne,
442  easeIn: G9,
443  easeInOut: fs,
444  easeOut: J9,
445  circIn: y5,
446  circInOut: gs,
447  circOut: ds,
448  backIn: v5,
449  backInOut: cs,
450  backOut: Ls,
451  anticipate: ls
452}, X9 = (t) => typeof t == "string", M0 = (t) => {
453  if (ps(t)) {
454    Xt(t.length === 4);
455    const [e, s, r, n] = t;
456    return u2(e, s, r, n);
457  } else if (X9(t))
458    return Y9[t];
459  return t;
460}, T2 = [
461  "setup",
462  // Compute
463  "read",
464  // Read
465  "resolveKeyframes",
466  // Write/Read/Write/Read
467  "preUpdate",
468  // Compute
469  "update",
470  // Compute
471  "preRender",
472  // Compute
473  "render",
474  // Write
475  "postRender"
476  // Compute
477];
478function Q9(t, e) {
479  let s = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), n = !1, o = !1;
480  const L = /* @__PURE__ */ new WeakSet();
481  let d = {
482    delta: 0,
483    timestamp: 0,
484    isProcessing: !1
485  };
486  function l(f) {
487    L.has(f) && (g.schedule(f), t()), f(d);
488  }
489  const g = {
490    /**
491     * Schedule a process to run on the next frame.
492     */
493    schedule: (f, p = !1, M = !1) => {
494      const h = M && n ? s : r;
495      return p && L.add(f), h.has(f) || h.add(f), f;
496    },
497    /**
498     * Cancel the provided callback from running on the next frame.
499     */
500    cancel: (f) => {
501      r.delete(f), L.delete(f);
502    },
503    /**
504     * Execute all schedule callbacks.
505     */
506    process: (f) => {
507      if (d = f, n) {
508        o = !0;
509        return;
510      }
511      n = !0, [s, r] = [r, s], s.forEach(l), s.clear(), n = !1, o && (o = !1, g.process(f));
512    }
513  };
514  return g;
515}
516const er = 40;
517function Ms(t, e) {
518  let s = !1, r = !0;
519  const n = {
520    delta: 0,
521    timestamp: 0,
522    isProcessing: !1
523  }, o = () => s = !0, L = T2.reduce((b, S) => (b[S] = Q9(o), b), {}), { setup: d, read: l, resolveKeyframes: g, preUpdate: f, update: p, preRender: M, render: u, postRender: h } = L, x = () => {
524    const b = u1.useManualTiming ? n.timestamp : performance.now();
525    s = !1, u1.useManualTiming || (n.delta = r ? 1e3 / 60 : Math.max(Math.min(b - n.timestamp, er), 1)), n.timestamp = b, n.isProcessing = !0, d.process(n), l.process(n), g.process(n), f.process(n), p.process(n), M.process(n), u.process(n), h.process(n), n.isProcessing = !1, s && e && (r = !1, t(x));
526  }, _ = () => {
527    s = !0, r = !0, n.isProcessing || t(x);
528  };
529  return { schedule: T2.reduce((b, S) => {
530    const k = L[S];
531    return b[S] = (A, I = !1, w = !1) => (s || _(), k.schedule(A, I, w)), b;
532  }, {}), cancel: (b) => {
533    for (let S = 0; S < T2.length; S++)
534      L[T2[S]].cancel(b);
535  }, state: n, steps: L };
536}
537const { schedule: $, cancel: Je, state: me, steps: G3 } = /* @__PURE__ */ Ms(typeof requestAnimationFrame < "u" ? requestAnimationFrame : Ne, !0);
538let G2;
539function tr() {
540  G2 = void 0;
541}
542const Ae = {
543  now: () => (G2 === void 0 && Ae.set(me.isProcessing || u1.useManualTiming ? me.timestamp : performance.now()), G2),
544  set: (t) => {
545    G2 = t, queueMicrotask(tr);
546  }
547}, us = (t) => (e) => typeof e == "string" && e.startsWith(t), w5 = /* @__PURE__ */ us("--"), ar = /* @__PURE__ */ us("var(--"), T5 = (t) => ar(t) ? sr.test(t.split("/*")[0].trim()) : !1, sr = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu, Bt = {
548  test: (t) => typeof t == "number",
549  parse: parseFloat,
550  transform: (t) => t
551}, Qt = {
552  ...Bt,
553  transform: (t) => i1(0, 1, t)
554}, S2 = {
555  ...Bt,
556  default: 1
557}, $t = (t) => Math.round(t * 1e5) / 1e5, S5 = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
558function ir(t) {
559  return t == null;
560}
561const rr = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, B5 = (t, e) => (s) => !!(typeof s == "string" && rr.test(s) && s.startsWith(t) || e && !ir(s) && Object.prototype.hasOwnProperty.call(s, e)), hs = (t, e, s) => (r) => {
562  if (typeof r != "string")
563    return r;
564  const [n, o, L, d] = r.match(S5);
565  return {
566    [t]: parseFloat(n),
567    [e]: parseFloat(o),
568    [s]: parseFloat(L),
569    alpha: d !== void 0 ? parseFloat(d) : 1
570  };
571}, nr = (t) => i1(0, 255, t), J3 = {
572  ...Bt,
573  transform: (t) => Math.round(nr(t))
574}, z1 = {
575  test: /* @__PURE__ */ B5("rgb", "red"),
576  parse: /* @__PURE__ */ hs("red", "green", "blue"),
577  transform: ({ red: t, green: e, blue: s, alpha: r = 1 }) => "rgba(" + J3.transform(t) + ", " + J3.transform(e) + ", " + J3.transform(s) + ", " + $t(Qt.transform(r)) + ")"
578};
579function or(t) {
580  let e = "", s = "", r = "", n = "";
581  return t.length > 5 ? (e = t.substring(1, 3), s = t.substring(3, 5), r = t.substring(5, 7), n = t.substring(7, 9)) : (e = t.substring(1, 2), s = t.substring(2, 3), r = t.substring(3, 4), n = t.substring(4, 5), e += e, s += s, r += r, n += n), {
582    red: parseInt(e, 16),
583    green: parseInt(s, 16),
584    blue: parseInt(r, 16),
585    alpha: n ? parseInt(n, 16) / 255 : 1
586  };
587}
588const T4 = {
589  test: /* @__PURE__ */ B5("#"),
590  parse: or,
591  transform: z1.transform
592}, h2 = /* @__NO_SIDE_EFFECTS__ */ (t) => ({
593  test: (e) => typeof e == "string" && e.endsWith(t) && e.split(" ").length === 1,
594  parse: parseFloat,
595  transform: (e) => `${e}${t}`
596}), m1 = /* @__PURE__ */ h2("deg"), a1 = /* @__PURE__ */ h2("%"), R = /* @__PURE__ */ h2("px"), Lr = /* @__PURE__ */ h2("vh"), cr = /* @__PURE__ */ h2("vw"), u0 = {
597  ...a1,
598  parse: (t) => a1.parse(t) / 100,
599  transform: (t) => a1.transform(t * 100)
600}, rt = {
601  test: /* @__PURE__ */ B5("hsl", "hue"),
602  parse: /* @__PURE__ */ hs("hue", "saturation", "lightness"),
603  transform: ({ hue: t, saturation: e, lightness: s, alpha: r = 1 }) => "hsla(" + Math.round(t) + ", " + a1.transform($t(e)) + ", " + a1.transform($t(s)) + ", " + $t(Qt.transform(r)) + ")"
604}, ge = {
605  test: (t) => z1.test(t) || T4.test(t) || rt.test(t),
606  parse: (t) => z1.test(t) ? z1.parse(t) : rt.test(t) ? rt.parse(t) : T4.parse(t),
607  transform: (t) => typeof t == "string" ? t : t.hasOwnProperty("red") ? z1.transform(t) : rt.transform(t),
608  getAnimatableNone: (t) => {
609    const e = ge.parse(t);
610    return e.alpha = 0, ge.transform(e);
611  }
612}, lr = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
613function dr(t) {
614  return isNaN(t) && typeof t == "string" && (t.match(S5)?.length || 0) + (t.match(lr)?.length || 0) > 0;
615}
616const ms = "number", xs = "color", gr = "var", fr = "var(", h0 = "${}", pr = /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;
617function e2(t) {
618  const e = t.toString(), s = [], r = {
619    color: [],
620    number: [],
621    var: []
622  }, n = [];
623  let o = 0;
624  const d = e.replace(pr, (l) => (ge.test(l) ? (r.color.push(o), n.push(xs), s.push(ge.parse(l))) : l.startsWith(fr) ? (r.var.push(o), n.push(gr), s.push(l)) : (r.number.push(o), n.push(ms), s.push(parseFloat(l))), ++o, h0)).split(h0);
625  return { values: s, split: d, indexes: r, types: n };
626}
627function _s(t) {
628  return e2(t).values;
629}
630function bs(t) {
631  const { split: e, types: s } = e2(t), r = e.length;
632  return (n) => {
633    let o = "";
634    for (let L = 0; L < r; L++)
635      if (o += e[L], n[L] !== void 0) {
636        const d = s[L];
637        d === ms ? o += $t(n[L]) : d === xs ? o += ge.transform(n[L]) : o += n[L];
638      }
639    return o;
640  };
641}
642const Mr = (t) => typeof t == "number" ? 0 : ge.test(t) ? ge.getAnimatableNone(t) : t;
643function ur(t) {
644  const e = _s(t);
645  return bs(t)(e.map(Mr));
646}
647const v1 = {
648  test: dr,
649  parse: _s,
650  createTransformer: bs,
651  getAnimatableNone: ur
652};
653function K3(t, e, s) {
654  return s < 0 && (s += 1), s > 1 && (s -= 1), s < 1 / 6 ? t + (e - t) * 6 * s : s < 1 / 2 ? e : s < 2 / 3 ? t + (e - t) * (2 / 3 - s) * 6 : t;
655}
656function hr({ hue: t, saturation: e, lightness: s, alpha: r }) {
657  t /= 360, e /= 100, s /= 100;
658  let n = 0, o = 0, L = 0;
659  if (!e)
660    n = o = L = s;
661  else {
662    const d = s < 0.5 ? s * (1 + e) : s + e - s * e, l = 2 * s - d;
663    n = K3(l, d, t + 1 / 3), o = K3(l, d, t), L = K3(l, d, t - 1 / 3);
664  }
665  return {
666    red: Math.round(n * 255),
667    green: Math.round(o * 255),
668    blue: Math.round(L * 255),
669    alpha: r
670  };
671}
672function r3(t, e) {
673  return (s) => s > 0 ? e : t;
674}
675const se = (t, e, s) => t + (e - t) * s, Y3 = (t, e, s) => {
676  const r = t * t, n = s * (e * e - r) + r;
677  return n < 0 ? 0 : Math.sqrt(n);
678}, mr = [T4, z1, rt], xr = (t) => mr.find((e) => e.test(t));
679function m0(t) {
680  const e = xr(t);
681  if (!e)
682    return !1;
683  let s = e.parse(t);
684  return e === rt && (s = hr(s)), s;
685}
686const x0 = (t, e) => {
687  const s = m0(t), r = m0(e);
688  if (!s || !r)
689    return r3(t, e);
690  const n = { ...s };
691  return (o) => (n.red = Y3(s.red, r.red, o), n.green = Y3(s.green, r.green, o), n.blue = Y3(s.blue, r.blue, o), n.alpha = se(s.alpha, r.alpha, o), z1.transform(n));
692}, S4 = /* @__PURE__ */ new Set(["none", "hidden"]);
693function _r(t, e) {
694  return S4.has(t) ? (s) => s <= 0 ? t : e : (s) => s >= 1 ? e : t;
695}
696function br(t, e) {
697  return (s) => se(t, e, s);
698}
699function k5(t) {
700  return typeof t == "number" ? br : typeof t == "string" ? T5(t) ? r3 : ge.test(t) ? x0 : wr : Array.isArray(t) ? vs : typeof t == "object" ? ge.test(t) ? x0 : vr : r3;
701}
702function vs(t, e) {
703  const s = [...t], r = s.length, n = t.map((o, L) => k5(o)(o, e[L]));
704  return (o) => {
705    for (let L = 0; L < r; L++)
706      s[L] = n[L](o);
707    return s;
708  };
709}
710function vr(t, e) {
711  const s = { ...t, ...e }, r = {};
712  for (const n in s)
713    t[n] !== void 0 && e[n] !== void 0 && (r[n] = k5(t[n])(t[n], e[n]));
714  return (n) => {
715    for (const o in r)
716      s[o] = r[o](n);
717    return s;
718  };
719}
720function yr(t, e) {
721  const s = [], r = { color: 0, var: 0, number: 0 };
722  for (let n = 0; n < e.values.length; n++) {
723    const o = e.types[n], L = t.indexes[o][r[o]], d = t.values[L] ?? 0;
724    s[n] = d, r[o]++;
725  }
726  return s;
727}
728const wr = (t, e) => {
729  const s = v1.createTransformer(e), r = e2(t), n = e2(e);
730  return r.indexes.var.length === n.indexes.var.length && r.indexes.color.length === n.indexes.color.length && r.indexes.number.length >= n.indexes.number.length ? S4.has(t) && !n.values.length || S4.has(e) && !r.values.length ? _r(t, e) : M2(vs(yr(r, n), n.values), s) : r3(t, e);
731};
732function ys(t, e, s) {
733  return typeof t == "number" && typeof e == "number" && typeof s == "number" ? se(t, e, s) : k5(t)(t, e);
734}
735const Tr = (t) => {
736  const e = ({ timestamp: s }) => t(s);
737  return {
738    start: (s = !0) => $.update(e, s),
739    stop: () => Je(e),
740    /**
741     * If we're processing this frame we can use the
742     * framelocked timestamp to keep things in sync.
743     */
744    now: () => me.isProcessing ? me.timestamp : Ae.now()
745  };
746}, ws = (t, e, s = 10) => {
747  let r = "";

748  const n = Math.max(Math.round(e / s), 2);
749  for (let o = 0; o < n; o++)
750    r += Math.round(t(o / (n - 1)) * 1e4) / 1e4 + ", ";
751  return `linear(${r.substring(0, r.length - 2)})`;
752}, n3 = 2e4;
753function A5(t) {
754  let e = 0;
755  const s = 50;
756  let r = t.next(e);
757  for (; !r.done && e < n3; )
758    e += s, r = t.next(e);
759  return e >= n3 ? 1 / 0 : e;
760}
761function Sr(t, e = 100, s) {
762  const r = s({ ...t, keyframes: [0, e] }), n = Math.min(A5(r), n3);
763  return {
764    type: "keyframes",
765    ease: (o) => r.next(n * o).value / e,
766    duration: /* @__PURE__ */ Oe(n)
767  };
768}
769const Br = 5;
770function Ts(t, e, s) {
771  const r = Math.max(e - Br, 0);
772  return b5(s - t(r), e - r);
773}
774const ne = {
775  // Default spring physics
776  stiffness: 100,
777  damping: 10,
778  mass: 1,
779  velocity: 0,
780  // Default duration/bounce-based options
781  duration: 800,
782  // in ms
783  bounce: 0.3,
784  visualDuration: 0.3,
785  // in seconds
786  // Rest thresholds
787  restSpeed: {
788    granular: 0.01,
789    default: 2
790  },
791  restDelta: {
792    granular: 5e-3,
793    default: 0.5
794  },
795  // Limits
796  minDuration: 0.01,
797  // in seconds
798  maxDuration: 10,
799  // in seconds
800  minDamping: 0.05,
801  maxDamping: 1
802}, X3 = 1e-3;
803function kr({ duration: t = ne.duration, bounce: e = ne.bounce, velocity: s = ne.velocity, mass: r = ne.mass }) {
804  let n, o, L = 1 - e;
805  L = i1(ne.minDamping, ne.maxDamping, L), t = i1(ne.minDuration, ne.maxDuration, /* @__PURE__ */ Oe(t)), L < 1 ? (n = (g) => {
806    const f = g * L, p = f * t, M = f - s, u = B4(g, L), h = Math.exp(-p);
807    return X3 - M / u * h;
808  }, o = (g) => {
809    const p = g * L * t, M = p * s + s, u = Math.pow(L, 2) * Math.pow(g, 2) * t, h = Math.exp(-p), x = B4(Math.pow(g, 2), L);
810    return (-n(g) + X3 > 0 ? -1 : 1) * ((M - u) * h) / x;
811  }) : (n = (g) => {
812    const f = Math.exp(-g * t), p = (g - s) * t + 1;
813    return -X3 + f * p;
814  }, o = (g) => {
815    const f = Math.exp(-g * t), p = (s - g) * (t * t);
816    return f * p;
817  });
818  const d = 5 / t, l = Nr(n, o, d);
819  if (t = /* @__PURE__ */ t1(t), isNaN(l))
820    return {
821      stiffness: ne.stiffness,
822      damping: ne.damping,
823      duration: t
824    };
825  {
826    const g = Math.pow(l, 2) * r;
827    return {
828      stiffness: g,
829      damping: L * 2 * Math.sqrt(r * g),
830      duration: t
831    };
832  }
833}
834const Ar = 12;
835function Nr(t, e, s) {
836  let r = s;
837  for (let n = 1; n < Ar; n++)
838    r = r - t(r) / e(r);
839  return r;
840}
841function B4(t, e) {
842  return t * Math.sqrt(1 - e * e);
843}
844const Ir = ["duration", "bounce"], Pr = ["stiffness", "damping", "mass"];
845function _0(t, e) {
846  return e.some((s) => t[s] !== void 0);
847}
848function Cr(t) {
849  let e = {
850    velocity: ne.velocity,
851    stiffness: ne.stiffness,
852    damping: ne.damping,
853    mass: ne.mass,
854    isResolvedFromDuration: !1,
855    ...t
856  };
857  if (!_0(t, Pr) && _0(t, Ir))
858    if (t.visualDuration) {
859      const s = t.visualDuration, r = 2 * Math.PI / (s * 1.2), n = r * r, o = 2 * i1(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(n);
860      e = {
861        ...e,
862        mass: ne.mass,
863        stiffness: n,
864        damping: o
865      };
866    } else {
867      const s = kr(t);
868      e = {
869        ...e,
870        ...s,
871        mass: ne.mass
872      }, e.isResolvedFromDuration = !0;
873    }
874  return e;
875}
876function o3(t = ne.visualDuration, e = ne.bounce) {
877  const s = typeof t != "object" ? {
878    visualDuration: t,
879    keyframes: [0, 1],
880    bounce: e
881  } : t;
882  let { restSpeed: r, restDelta: n } = s;
883  const o = s.keyframes[0], L = s.keyframes[s.keyframes.length - 1], d = { done: !1, value: o }, { stiffness: l, damping: g, mass: f, duration: p, velocity: M, isResolvedFromDuration: u } = Cr({
884    ...s,
885    velocity: -/* @__PURE__ */ Oe(s.velocity || 0)
886  }), h = M || 0, x = g / (2 * Math.sqrt(l * f)), _ = L - o, v = /* @__PURE__ */ Oe(Math.sqrt(l / f)), y = Math.abs(_) < 5;
887  r || (r = y ? ne.restSpeed.granular : ne.restSpeed.default), n || (n = y ? ne.restDelta.granular : ne.restDelta.default);
888  let b;
889  if (x < 1) {
890    const k = B4(v, x);
891    b = (A) => {
892      const I = Math.exp(-x * v * A);
893      return L - I * ((h + x * v * _) / k * Math.sin(k * A) + _ * Math.cos(k * A));
894    };
895  } else if (x === 1)
896    b = (k) => L - Math.exp(-v * k) * (_ + (h + v * _) * k);
897  else {

898    const k = v * Math.sqrt(x * x - 1);
899    b = (A) => {
900      const I = Math.exp(-x * v * A), w = Math.min(k * A, 300);
901      return L - I * ((h + x * v * _) * Math.sinh(w) + k * _ * Math.cosh(w)) / k;
902    };
903  }
904  const S = {
905    calculatedDuration: u && p || null,
906    next: (k) => {
907      const A = b(k);
908      if (u)
909        d.done = k >= p;
910      else {
911        let I = k === 0 ? h : 0;
912        x < 1 && (I = k === 0 ? /* @__PURE__ */ t1(h) : Ts(b, k, A));
913        const w = Math.abs(I) <= r, P = Math.abs(L - A) <= n;
914        d.done = w && P;
915      }
916      return d.value = d.done ? L : A, d;
917    },
918    toString: () => {
919      const k = Math.min(A5(S), n3), A = ws((I) => S.next(k * I).value, k, 30);
920      return k + "ms " + A;
921    },
922    toTransition: () => {
923    }
924  };
925  return S;
926}
927o3.applyToOptions = (t) => {
928  const e = Sr(t, 100, o3);
929  return t.ease = e.ease, t.duration = /* @__PURE__ */ t1(e.duration), t.type = "keyframes", t;
930};
931function k4({ keyframes: t, velocity: e = 0, power: s = 0.8, timeConstant: r = 325, bounceDamping: n = 10, bounceStiffness: o = 500, modifyTarget: L, min: d, max: l, restDelta: g = 0.5, restSpeed: f }) {
932  const p = t[0], M = {
933    done: !1,
934    value: p
935  }, u = (w) => d !== void 0 && w < d || l !== void 0 && w > l, h = (w) => d === void 0 ? l : l === void 0 || Math.abs(d - w) < Math.abs(l - w) ? d : l;
936  let x = s * e;
937  const _ = p + x, v = L === void 0 ? _ : L(_);
938  v !== _ && (x = v - p);
939  const y = (w) => -x * Math.exp(-w / r), b = (w) => v + y(w), S = (w) => {
940    const P = y(w), z = b(w);
941    M.done = Math.abs(P) <= g, M.value = M.done ? v : z;
942  };
943  let k, A;
944  const I = (w) => {
945    u(M.value) && (k = w, A = o3({
946      keyframes: [M.value, h(M.value)],
947      velocity: Ts(b, w, M.value),
948      // TODO: This should be passing * 1000
949      damping: n,
950      stiffness: o,
951      restDelta: g,
952      restSpeed: f
953    }));
954  };
955  return I(0), {
956    calculatedDuration: null,
957    next: (w) => {
958      let P = !1;
959      return !A && k === void 0 && (P = !0, S(w), I(w)), k !== void 0 && w >= k ? A.next(w - k) : (!P && S(w), M);
960    }
961  };
962}
963function Fr(t, e, s) {
964  const r = [], n = s || u1.mix || ys, o = t.length - 1;
965  for (let L = 0; L < o; L++) {
966    let d = n(t[L], t[L + 1]);
967    if (e) {
968      const l = Array.isArray(e) ? e[L] || Ne : e;
969      d = M2(l, d);
970    }
971    r.push(d);
972  }
973  return r;
974}
975function N5(t, e, { clamp: s = !0, ease: r, mixer: n } = {}) {
976  const o = t.length;
977  if (Xt(o === e.length), o === 1)
978    return () => e[0];
979  if (o === 2 && e[0] === e[1])
980    return () => e[1];
981  const L = t[0] === t[1];
982  t[0] > t[o - 1] && (t = [...t].reverse(), e = [...e].reverse());
983  const d = Fr(e, r, n), l = d.length, g = (f) => {
984    if (L && f < t[0])
985      return e[0];
986    let p = 0;
987    if (l > 1)
988      for (; p < t.length - 2 && !(f < t[p + 1]); p++)
989        ;
990    const M = /* @__PURE__ */ vt(t[p], t[p + 1], f);
991    return d[p](M);
992  };
993  return s ? (f) => g(i1(t[0], t[o - 1], f)) : g;
994}
995function Er(t, e) {
996  const s = t[t.length - 1];
997  for (let r = 1; r <= e; r++) {
998    const n = /* @__PURE__ */ vt(0, e, r);
999    t.push(se(s, 1, n));
1000  }
1001}
1002function Ss(t) {
1003  const e = [0];
1004  return Er(e, t.length - 1), e;
1005}
1006function Rr(t, e) {
1007  return t.map((s) => s * e);
1008}
1009function Dr(t, e) {
1010  return t.map(() => e || fs).splice(0, t.length - 1);
1011}
1012function qt({ duration: t = 300, keyframes: e, times: s, ease: r = "easeInOut" }) {
1013  const n = K9(r) ? r.map(M0) : M0(r), o = {
1014    done: !1,
1015    value: e[0]
1016  }, L = Rr(
1017    // Only use the provided offsets if they're the correct length
1018    // TODO Maybe we should warn here if there's a length mismatch
1019    s && s.length === e.length ? s : Ss(e),
1020    t
1021  ), d = N5(L, e, {
1022    ease: Array.isArray(n) ? n : Dr(e, n)
1023  });
1024  return {
1025    calculatedDuration: t,
1026    next: (l) => (o.value = d(l), o.done = l >= t, o)
1027  };
1028}
1029const zr = (t) => t !== null;
1030function I5(t, { repeat: e, repeatType: s = "loop" }, r, n = 1) {
1031  const o = t.filter(zr), d = n < 0 || e && s !== "loop" && e % 2 === 1 ? 0 : o.length - 1;
1032  return !d || r === void 0 ? o[d] : r;
1033}
1034const jr = {
1035  decay: k4,
1036  inertia: k4,
1037  tween: qt,
1038  keyframes: qt,
1039  spring: o3
1040};
1041function Bs(t) {
1042  typeof t.type == "string" && (t.type = jr[t.type]);
1043}
1044class P5 {
1045  constructor() {
1046    this.updateFinished();
1047  }
1048  get finished() {
1049    return this._finished;
1050  }
1051  updateFinished() {
1052    this._finished = new Promise((e) => {
1053      this.resolve = e;
1054    });
1055  }
1056  notifyFinished() {
1057    this.resolve();
1058  }
1059  /**
1060   * Allows the animation to be awaited.
1061   *
1062   * @deprecated Use `finished` instead.
1063   */
1064  then(e, s) {
1065    return this.finished.then(e, s);
1066  }
1067}
1068const Or = (t) => t / 100;
1069class S3 extends P5 {
1070  constructor(e) {
1071    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
1072      const { motionValue: s } = this.options;
1073      s && s.updatedAt !== Ae.now() && this.tick(Ae.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
1074    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
1075  }
1076  initAnimation() {
1077    const { options: e } = this;
1078    Bs(e);
1079    const { type: s = qt, repeat: r = 0, repeatDelay: n = 0, repeatType: o, velocity: L = 0 } = e;
1080    let { keyframes: d } = e;
1081    const l = s || qt;
1082    l !== qt && typeof d[0] != "number" && (this.mixKeyframes = M2(Or, ys(d[0], d[1])), d = [0, 100]);
1083    const g = l({ ...e, keyframes: d });
1084    o === "mirror" && (this.mirroredGenerator = l({
1085      ...e,
1086      keyframes: [...d].reverse(),
1087      velocity: -L
1088    })), g.calculatedDuration === null && (g.calculatedDuration = A5(g));
1089    const { calculatedDuration: f } = g;
1090    this.calculatedDuration = f, this.resolvedDuration = f + n, this.totalDuration = this.resolvedDuration * (r + 1) - n, this.generator = g;
1091  }
1092  updateTime(e) {
1093    const s = Math.round(e - this.startTime) * this.playbackSpeed;
1094    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = s;
1095  }
1096  tick(e, s = !1) {
1097    const { generator: r, totalDuration: n, mixKeyframes: o, mirroredGenerator: L, resolvedDuration: d, calculatedDuration: l } = this;
1098    if (this.startTime === null)
1099      return r.next(0);
1100    const { delay: g = 0, keyframes: f, repeat: p, repeatType: M, repeatDelay: u, type: h, onUpdate: x, finalKeyframe: _ } = this.options;
1101    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - n / this.speed, this.startTime)), s ? this.currentTime = e : this.updateTime(e);
1102    const v = this.currentTime - g * (this.playbackSpeed >= 0 ? 1 : -1), y = this.playbackSpeed >= 0 ? v < 0 : v > n;
1103    this.currentTime = Math.max(v, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = n);
1104    let b = this.currentTime, S = r;
1105    if (p) {
1106      const w = Math.min(this.currentTime, n) / d;
1107      let P = Math.floor(w), z = w % 1;
1108      !z && w >= 1 && (z = 1), z === 1 && P--, P = Math.min(P, p + 1), !!(P % 2) && (M === "reverse" ? (z = 1 - z, u && (z -= u / d)) : M === "mirror" && (S = L)), b = i1(0, 1, z) * d;
1109    }
1110    const k = y ? { done: !1, value: f[0] } : S.next(b);
1111    o && (k.value = o(k.value));
1112    let { done: A } = k;
1113    !y && l !== null && (A = this.playbackSpeed >= 0 ? this.currentTime >= n : this.currentTime <= 0);
1114    const I = this.holdTime === null && (this.state === "finished" || this.state === "running" && A);
1115    return I && h !== k4 && (k.value = I5(f, this.options, _, this.speed)), x && x(k.value), I && this.finish(), k;
1116  }
1117  /**
1118   * Allows the returned animation to be awaited or promise-chained. Currently
1119   * resolves when the animation finishes at all but in a future update could/should
1120   * reject if its cancels.
1121   */
1122  then(e, s) {
1123    return this.finished.then(e, s);
1124  }
1125  get duration() {
1126    return /* @__PURE__ */ Oe(this.calculatedDuration);
1127  }
1128  get iterationDuration() {
1129    const { delay: e = 0 } = this.options || {};
1130    return this.duration + /* @__PURE__ */ Oe(e);
1131  }
1132  get time() {
1133    return /* @__PURE__ */ Oe(this.currentTime);
1134  }
1135  set time(e) {
1136    e = /* @__PURE__ */ t1(e), this.currentTime = e, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.playbackSpeed), this.driver?.start(!1);
1137  }
1138  get speed() {
1139    return this.playbackSpeed;
1140  }
1141  set speed(e) {
1142    this.updateTime(Ae.now());
1143    const s = this.playbackSpeed !== e;
1144    this.playbackSpeed = e, s && (this.time = /* @__PURE__ */ Oe(this.currentTime));
1145  }
1146  play() {
1147    if (this.isStopped)
1148      return;
1149    const { driver: e = Tr, startTime: s } = this.options;
1150    this.driver || (this.driver = e((n) => this.tick(n))), this.options.onPlay?.();
1151    const r = this.driver.now();
1152    this.state === "finished" ? (this.updateFinished(), this.startTime = r) : this.holdTime !== null ? this.startTime = r - this.holdTime : this.startTime || (this.startTime = s ?? r), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
1153  }
1154  pause() {
1155    this.state = "paused", this.updateTime(Ae.now()), this.holdTime = this.currentTime;
1156  }
1157  complete() {
1158    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
1159  }
1160  finish() {
1161    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
1162  }
1163  cancel() {
1164    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
1165  }
1166  teardown() {
1167    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
1168  }
1169  stopDriver() {
1170    this.driver && (this.driver.stop(), this.driver = void 0);
1171  }
1172  sample(e) {
1173    return this.startTime = 0, this.tick(e, !0);
1174  }
1175  attachTimeline(e) {
1176    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), e.observe(this);
1177  }
1178}
1179function Vr(t) {
1180  for (let e = 1; e < t.length; e++)
1181    t[e] ?? (t[e] = t[e - 1]);
1182}
1183const j1 = (t) => t * 180 / Math.PI, A4 = (t) => {
1184  const e = j1(Math.atan2(t[1], t[0]));
1185  return N4(e);
1186}, Hr = {
1187  x: 4,
1188  y: 5,
1189  translateX: 4,
1190  translateY: 5,
1191  scaleX: 0,
1192  scaleY: 3,
1193  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
1194  rotate: A4,
1195  rotateZ: A4,
1196  skewX: (t) => j1(Math.atan(t[1])),
1197  skewY: (t) => j1(Math.atan(t[2])),
1198  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
1199}, N4 = (t) => (t = t % 360, t < 0 && (t += 360), t), b0 = A4, v0 = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), y0 = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), Zr = {
1200  x: 12,
1201  y: 13,
1202  z: 14,
1203  translateX: 12,
1204  translateY: 13,
1205  translateZ: 14,
1206  scaleX: v0,
1207  scaleY: y0,
1208  scale: (t) => (v0(t) + y0(t)) / 2,
1209  rotateX: (t) => N4(j1(Math.atan2(t[6], t[5]))),
1210  rotateY: (t) => N4(j1(Math.atan2(-t[2], t[0]))),
1211  rotateZ: b0,
1212  rotate: b0,
1213  skewX: (t) => j1(Math.atan(t[4])),
1214  skewY: (t) => j1(Math.atan(t[1])),
1215  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
1216};
1217function I4(t) {
1218  return t.includes("scale") ? 1 : 0;
1219}
1220function P4(t, e) {
1221  if (!t || t === "none")
1222    return I4(e);
1223  const s = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
1224  let r, n;
1225  if (s)
1226    r = Zr, n = s;
1227  else {
1228    const d = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
1229    r = Hr, n = d;
1230  }
1231  if (!n)
1232    return I4(e);
1233  const o = r[e], L = n[1].split(",").map($r);
1234  return typeof o == "function" ? o(L) : L[o];
1235}
1236const Wr = (t, e) => {
1237  const { transform: s = "none" } = getComputedStyle(t);
1238  return P4(s, e);
1239};
1240function $r(t) {
1241  return parseFloat(t.trim());
1242}
1243const kt = [
1244  "transformPerspective",
1245  "x",
1246  "y",
1247  "z",
1248  "translateX",
1249  "translateY",
1250  "translateZ",
1251  "scale",
1252  "scaleX",
1253  "scaleY",
1254  "rotate",
1255  "rotateX",
1256  "rotateY",
1257  "rotateZ",
1258  "skew",
1259  "skewX",
1260  "skewY"
1261], At = new Set(kt), w0 = (t) => t === Bt || t === R, qr = /* @__PURE__ */ new Set(["x", "y", "z"]), Ur = kt.filter((t) => !qr.has(t));
1262function Gr(t) {
1263  const e = [];
1264  return Ur.forEach((s) => {
1265    const r = t.getValue(s);
1266    r !== void 0 && (e.push([s, r.get()]), r.set(s.startsWith("scale") ? 1 : 0));
1267  }), e;
1268}
1269const q1 = {
1270  // Dimensions
1271  width: ({ x: t }, { paddingLeft: e = "0", paddingRight: s = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(s),
1272  height: ({ y: t }, { paddingTop: e = "0", paddingBottom: s = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(s),
1273  top: (t, { top: e }) => parseFloat(e),
1274  left: (t, { left: e }) => parseFloat(e),
1275  bottom: ({ y: t }, { top: e }) => parseFloat(e) + (t.max - t.min),
1276  right: ({ x: t }, { left: e }) => parseFloat(e) + (t.max - t.min),
1277  // Transform
1278  x: (t, { transform: e }) => P4(e, "x"),
1279  y: (t, { transform: e }) => P4(e, "y")
1280};
1281q1.translateX = q1.x;
1282q1.translateY = q1.y;
1283const U1 = /* @__PURE__ */ new Set();
1284let C4 = !1, F4 = !1, E4 = !1;
1285function ks() {
1286  if (F4) {
1287    const t = Array.from(U1).filter((r) => r.needsMeasurement), e = new Set(t.map((r) => r.element)), s = /* @__PURE__ */ new Map();
1288    e.forEach((r) => {
1289      const n = Gr(r);
1290      n.length && (s.set(r, n), r.render());
1291    }), t.forEach((r) => r.measureInitialState()), e.forEach((r) => {
1292      r.render();
1293      const n = s.get(r);
1294      n && n.forEach(([o, L]) => {
1295        r.getValue(o)?.set(L);
1296      });
1297    }), t.forEach((r) => r.measureEndState()), t.forEach((r) => {
1298      r.suspendedScrollY !== void 0 && window.scrollTo(0, r.suspendedScrollY);
1299    });
1300  }
1301  F4 = !1, C4 = !1, U1.forEach((t) => t.complete(E4)), U1.clear();
1302}
1303function As() {
1304  U1.forEach((t) => {
1305    t.readKeyframes(), t.needsMeasurement && (F4 = !0);
1306  });
1307}
1308function Jr() {
1309  E4 = !0, As(), ks(), E4 = !1;
1310}
1311class C5 {
1312  constructor(e, s, r, n, o, L = !1) {
1313    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...e], this.onComplete = s, this.name = r, this.motionValue = n, this.element = o, this.isAsync = L;
1314  }
1315  scheduleResolve() {
1316    this.state = "scheduled", this.isAsync ? (U1.add(this), C4 || (C4 = !0, $.read(As), $.resolveKeyframes(ks))) : (this.readKeyframes(), this.complete());
1317  }
1318  readKeyframes() {
1319    const { unresolvedKeyframes: e, name: s, element: r, motionValue: n } = this;
1320    if (e[0] === null) {
1321      const o = n?.get(), L = e[e.length - 1];
1322      if (o !== void 0)
1323        e[0] = o;
1324      else if (r && s) {
1325        const d = r.readValue(s, L);
1326        d != null && (e[0] = d);
1327      }
1328      e[0] === void 0 && (e[0] = L), n && o === void 0 && n.set(e[0]);
1329    }
1330    Vr(e);
1331  }
1332  setFinalKeyframe() {
1333  }
1334  measureInitialState() {
1335  }
1336  renderEndStyles() {
1337  }
1338  measureEndState() {
1339  }
1340  complete(e = !1) {
1341    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, e), U1.delete(this);
1342  }
1343  cancel() {
1344    this.state === "scheduled" && (U1.delete(this), this.state = "pending");
1345  }
1346  resume() {
1347    this.state === "pending" && this.scheduleResolve();
1348  }
1349}
1350const Kr = (t) => t.startsWith("--");
1351function Yr(t, e, s) {
1352  Kr(e) ? t.style.setProperty(e, s) : t.style[e] = s;
1353}
1354const Ns = /* @__PURE__ */ x5(() => window.ScrollTimeline !== void 0), Xr = {};
1355function Qr(t, e) {
1356  const s = /* @__PURE__ */ x5(t);
1357  return () => Xr[e] ?? s();
1358}
1359const Is = /* @__PURE__ */ Qr(() => {
1360  try {
1361    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
1362  } catch {
1363    return !1;
1364  }
1365  return !0;
1366}, "linearEasing"), Vt = ([t, e, s, r]) => `cubic-bezier(${t}, ${e}, ${s}, ${r})`, T0 = {
1367  linear: "linear",
1368  ease: "ease",
1369  easeIn: "ease-in",
1370  easeOut: "ease-out",
1371  easeInOut: "ease-in-out",
1372  circIn: /* @__PURE__ */ Vt([0, 0.65, 0.55, 1]),
1373  circOut: /* @__PURE__ */ Vt([0.55, 0, 1, 0.45]),
1374  backIn: /* @__PURE__ */ Vt([0.31, 0.01, 0.66, -0.59]),
1375  backOut: /* @__PURE__ */ Vt([0.33, 1.53, 0.69, 0.99])
1376};
1377function Ps(t, e) {
1378  if (t)
1379    return typeof t == "function" ? Is() ? ws(t, e) : "ease-out" : ps(t) ? Vt(t) : Array.isArray(t) ? t.map((s) => Ps(s, e) || T0.easeOut) : T0[t];
1380}
1381function en(t, e, s, { delay: r = 0, duration: n = 300, repeat: o = 0, repeatType: L = "loop", ease: d = "easeOut", times: l } = {}, g = void 0) {
1382  const f = {
1383    [e]: s
1384  };
1385  l && (f.offset = l);
1386  const p = Ps(d, n);
1387  Array.isArray(p) && (f.easing = p);
1388  const M = {
1389    delay: r,
1390    duration: n,
1391    easing: Array.isArray(p) ? "linear" : p,
1392    fill: "both",
1393    iterations: o + 1,
1394    direction: L === "reverse" ? "alternate" : "normal"
1395  };
1396  return g && (M.pseudoElement = g), t.animate(f, M);
1397}
1398function Cs(t) {
1399  return typeof t == "function" && "applyToOptions" in t;
1400}
1401function tn({ type: t, ...e }) {
1402  return Cs(t) && Is() ? t.applyToOptions(e) : (e.duration ?? (e.duration = 300), e.ease ?? (e.ease = "easeOut"), e);
1403}
1404class an extends P5 {
1405  constructor(e) {
1406    if (super(), this.finishedTime = null, this.isStopped = !1, !e)
1407      return;
1408    const { element: s, name: r, keyframes: n, pseudoElement: o, allowFlatten: L = !1, finalKeyframe: d, onComplete: l } = e;
1409    this.isPseudoElement = !!o, this.allowFlatten = L, this.options = e, Xt(typeof e.type != "string");
1410    const g = tn(e);
1411    this.animation = en(s, r, n, g, o), g.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
1412      if (this.finishedTime = this.time, !o) {
1413        const f = I5(n, this.options, d, this.speed);
1414        this.updateMotionValue ? this.updateMotionValue(f) : Yr(s, r, f), this.animation.cancel();
1415      }
1416      l?.(), this.notifyFinished();
1417    };
1418  }
1419  play() {
1420    this.isStopped || (this.animation.play(), this.state === "finished" && this.updateFinished());
1421  }
1422  pause() {
1423    this.animation.pause();
1424  }
1425  complete() {
1426    this.animation.finish?.();
1427  }
1428  cancel() {
1429    try {
1430      this.animation.cancel();
1431    } catch {
1432    }
1433  }
1434  stop() {
1435    if (this.isStopped)
1436      return;
1437    this.isStopped = !0;
1438    const { state: e } = this;

1707  const [r] = s.match(S5) || [];
1708  if (!r)
1709    return t;
1710  const n = s.replace(r, "");
1711  let o = mn.has(e) ? 1 : 0;
1712  return r !== s && (o *= 100), e + "(" + o + n + ")";
1713}
1714const _n = /\b([a-z-]*)\(.*?\)/gu, D4 = {
1715  ...v1,
1716  getAnimatableNone: (t) => {
1717    const e = t.match(_n);
1718    return e ? e.map(xn).join(" ") : t;
1719  }
1720}, A0 = {
1721  ...Bt,
1722  transform: Math.round
1723}, bn = {
1724  rotate: m1,
1725  rotateX: m1,
1726  rotateY: m1,
1727  rotateZ: m1,
1728  scale: S2,
1729  scaleX: S2,
1730  scaleY: S2,
1731  scaleZ: S2,
1732  skew: m1,
1733  skewX: m1,
1734  skewY: m1,
1735  distance: R,
1736  translateX: R,
1737  translateY: R,
1738  translateZ: R,
1739  x: R,
1740  y: R,
1741  z: R,
1742  perspective: R,
1743  transformPerspective: R,
1744  opacity: Qt,
1745  originX: u0,
1746  originY: u0,
1747  originZ: R
1748}, E5 = {
1749  // Border props
1750  borderWidth: R,
1751  borderTopWidth: R,
1752  borderRightWidth: R,
1753  borderBottomWidth: R,
1754  borderLeftWidth: R,
1755  borderRadius: R,
1756  radius: R,
1757  borderTopLeftRadius: R,
1758  borderTopRightRadius: R,
1759  borderBottomRightRadius: R,
1760  borderBottomLeftRadius: R,
1761  // Positioning props
1762  width: R,
1763  maxWidth: R,
1764  height: R,
1765  maxHeight: R,
1766  top: R,
1767  right: R,
1768  bottom: R,
1769  left: R,
1770  // Spacing props
1771  padding: R,
1772  paddingTop: R,
1773  paddingRight: R,
1774  paddingBottom: R,
1775  paddingLeft: R,
1776  margin: R,
1777  marginTop: R,
1778  marginRight: R,
1779  marginBottom: R,
1780  marginLeft: R,
1781  // Misc
1782  backgroundPositionX: R,
1783  backgroundPositionY: R,
1784  ...bn,
1785  zIndex: A0,
1786  // SVG
1787  fillOpacity: Qt,
1788  strokeOpacity: Qt,
1789  numOctaves: A0
1790}, vn = {
1791  ...E5,
1792  // Color props
1793  color: ge,
1794  backgroundColor: ge,
1795  outlineColor: ge,
1796  fill: ge,
1797  stroke: ge,
1798  // Border props
1799  borderColor: ge,
1800  borderTopColor: ge,
1801  borderRightColor: ge,
1802  borderBottomColor: ge,
1803  borderLeftColor: ge,
1804  filter: D4,
1805  WebkitFilter: D4
1806}, js = (t) => vn[t];
1807function Os(t, e) {
1808  let s = js(t);
1809  return s !== D4 && (s = v1), s.getAnimatableNone ? s.getAnimatableNone(e) : void 0;
1810}
1811const yn = /* @__PURE__ */ new Set(["auto", "none", "0"]);
1812function wn(t, e, s) {
1813  let r = 0, n;
1814  for (; r < t.length && !n; ) {
1815    const o = t[r];
1816    typeof o == "string" && !yn.has(o) && e2(o).values.length && (n = t[r]), r++;
1817  }
1818  if (n && s)
1819    for (const o of e)
1820      t[o] = Os(s, n);
1821}
1822class Tn extends C5 {
1823  constructor(e, s, r, n, o) {
1824    super(e, s, r, n, o, !0);
1825  }
1826  readKeyframes() {
1827    const { unresolvedKeyframes: e, element: s, name: r } = this;
1828    if (!s || !s.current)
1829      return;
1830    super.readKeyframes();
1831    for (let l = 0; l < e.length; l++) {
1832      let g = e[l];
1833      if (typeof g == "string" && (g = g.trim(), T5(g))) {
1834        const f = Es(g, s.current);
1835        f !== void 0 && (e[l] = f), l === e.length - 1 && (this.finalKeyframe = g);
1836      }
1837    }
1838    if (this.resolveNoneKeyframes(), !Rs.has(r) || e.length !== 2)
1839      return;
1840    const [n, o] = e, L = k0(n), d = k0(o);
1841    if (L !== d)
1842      if (w0(L) && w0(d))
1843        for (let l = 0; l < e.length; l++) {
1844          const g = e[l];
1845          typeof g == "string" && (e[l] = parseFloat(g));
1846        }
1847      else q1[r] && (this.needsMeasurement = !0);
1848  }
1849  resolveNoneKeyframes() {
1850    const { unresolvedKeyframes: e, name: s } = this, r = [];
1851    for (let n = 0; n < e.length; n++)
1852      (e[n] === null || hn(e[n])) && r.push(n);
1853    r.length && wn(e, r, s);
1854  }
1855  measureInitialState() {
1856    const { element: e, unresolvedKeyframes: s, name: r } = this;
1857    if (!e || !e.current)
1858      return;
1859    r === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = q1[r](e.measureViewportBox(), window.getComputedStyle(e.current)), s[0] = this.measuredOrigin;
1860    const n = s[s.length - 1];
1861    n !== void 0 && e.getValue(r, n).jump(n, !1);
1862  }
1863  measureEndState() {
1864    const { element: e, name: s, unresolvedKeyframes: r } = this;
1865    if (!e || !e.current)
1866      return;
1867    const n = e.getValue(s);
1868    n && n.jump(this.measuredOrigin, !1);
1869    const o = r.length - 1, L = r[o];
1870    r[o] = q1[s](e.measureViewportBox(), window.getComputedStyle(e.current)), L !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = L), this.removedTransforms?.length && this.removedTransforms.forEach(([d, l]) => {
1871      e.getValue(d).set(l);
1872    }), this.resolveNoneKeyframes();
1873  }
1874}
1875function R5(t, e, s) {
1876  if (t instanceof EventTarget)
1877    return [t];
1878  if (typeof t == "string") {
1879    const n = document.querySelectorAll(t);
1880    return n ? Array.from(n) : [];
1881  }
1882  return Array.from(t);
1883}
1884const Vs = (t, e) => e && typeof t == "number" ? e.transform(t) : t;
1885function D5(t) {
1886  return ss(t) && "offsetHeight" in t;
1887}
1888const N0 = 30, Sn = (t) => !isNaN(parseFloat(t)), Ut = {
1889  current: void 0
1890};
1891class Bn {
1892  /**
1893   * @param init - The initiating value
1894   * @param config - Optional configuration options
1895   *
1896   * -  `transformer`: A function to transform incoming values with.
1897   */
1898  constructor(e, s = {}) {
1899    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (r) => {
1900      const n = Ae.now();
1901      if (this.updatedAt !== n && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(r), this.current !== this.prev && (this.events.change?.notify(this.current), this.dependents))
1902        for (const o of this.dependents)
1903          o.dirty();
1904    }, this.hasAnimated = !1, this.setCurrent(e), this.owner = s.owner;
1905  }
1906  setCurrent(e) {
1907    this.current = e, this.updatedAt = Ae.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = Sn(this.current));
1908  }
1909  setPrevFrameValue(e = this.current) {
1910    this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt;
1911  }
1912  /**
1913   * Adds a function that will be notified when the `MotionValue` is updated.
1914   *
1915   * It returns a function that, when called, will cancel the subscription.
1916   *
1917   * When calling `onChange` inside a React component, it should be wrapped with the
1918   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
1919   * from the `useEffect` function to ensure you don't add duplicate subscribers..
1920   *
1921   * ```jsx
1922   * export const MyComponent = () => {
1923   *   const x = useMotionValue(0)
1924   *   const y = useMotionValue(0)
1925   *   const opacity = useMotionValue(1)
1926   *
1927   *   useEffect(() => {
1928   *     function updateOpacity() {
1929   *       const maxXY = Math.max(x.get(), y.get())
1930   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
1931   *       opacity.set(newOpacity)
1932   *     }
1933   *
1934   *     const unsubscribeX = x.on("change", updateOpacity)
1935   *     const unsubscribeY = y.on("change", updateOpacity)
1936   *
1937   *     return () => {
1938   *       unsubscribeX()
1939   *       unsubscribeY()
1940   *     }
1941   *   }, [])
1942   *
1943   *   return <motion.div style={{ x }} />
1944   * }
1945   * ```
1946   *
1947   * @param subscriber - A function that receives the latest value.
1948   * @returns A function that, when called, will cancel this subscription.
1949   *
1950   * @deprecated
1951   */
1952  onChange(e) {
1953    return this.on("change", e);
1954  }
1955  on(e, s) {
1956    this.events[e] || (this.events[e] = new _5());
1957    const r = this.events[e].add(s);
1958    return e === "change" ? () => {
1959      r(), $.read(() => {
1960        this.events.change.getSize() || this.stop();
1961      });
1962    } : r;
1963  }
1964  clearListeners() {
1965    for (const e in this.events)
1966      this.events[e].clear();
1967  }
1968  /**
1969   * Attaches a passive effect to the `MotionValue`.
1970   */
1971  attach(e, s) {
1972    this.passiveEffect = e, this.stopPassiveEffect = s;
1973  }
1974  /**
1975   * Sets the state of the `MotionValue`.
1976   *
1977   * @remarks
1978   *
1979   * ```jsx
1980   * const x = useMotionValue(0)
1981   * x.set(10)
1982   * ```
1983   *
1984   * @param latest - Latest value to set.
1985   * @param render - Whether to notify render subscribers. Defaults to `true`
1986   *
1987   * @public
1988   */
1989  set(e) {
1990    this.passiveEffect ? this.passiveEffect(e, this.updateAndNotify) : this.updateAndNotify(e);
1991  }
1992  setWithVelocity(e, s, r) {
1993    this.set(s), this.prev = void 0, this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt - r;
1994  }
1995  /**
1996   * Set the state of the `MotionValue`, stopping any active animations,
1997   * effects, and resets velocity to `0`.
1998   */
1999  jump(e, s = !0) {
2000    this.updateAndNotify(e), this.prev = e, this.prevUpdatedAt = this.prevFrameValue = void 0, s && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
2001  }
2002  dirty() {
2003    this.events.change?.notify(this.current);
2004  }
2005  addDependent(e) {
2006    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(e);
2007  }
2008  removeDependent(e) {
2009    this.dependents && this.dependents.delete(e);
2010  }
2011  /**
2012   * Returns the latest state of `MotionValue`
2013   *
2014   * @returns - The latest state of `MotionValue`
2015   *
2016   * @public
2017   */
2018  get() {
2019    return Ut.current && Ut.current.push(this), this.current;
2020  }
2021  /**
2022   * @public
2023   */
2024  getPrevious() {
2025    return this.prev;
2026  }
2027  /**
2028   * Returns the latest velocity of `MotionValue`
2029   *
2030   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
2031   *
2032   * @public
2033   */
2034  getVelocity() {
2035    const e = Ae.now();
2036    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > N0)
2037      return 0;
2038    const s = Math.min(this.updatedAt - this.prevUpdatedAt, N0);
2039    return b5(parseFloat(this.current) - parseFloat(this.prevFrameValue), s);
2040  }
2041  /**
2042   * Registers a new animation to control this `MotionValue`. Only one
2043   * animation can drive a `MotionValue` at one time.
2044   *
2045   * ```jsx
2046   * value.start()
2047   * ```
2048   *
2049   * @param animation - A function that starts the provided animation
2050   */
2051  start(e) {
2052    return this.stop(), new Promise((s) => {
2053      this.hasAnimated = !0, this.animation = e(s), this.events.animationStart && this.events.animationStart.notify();
2054    }).then(() => {
2055      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
2056    });
2057  }
2058  /**
2059   * Stop the currently active animation.
2060   *
2061   * @public
2062   */
2063  stop() {
2064    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
2065  }
2066  /**
2067   * Returns `true` if this value is currently animating.
2068   *
2069   * @public
2070   */
2071  isAnimating() {
2072    return !!this.animation;
2073  }
2074  clearAnimation() {
2075    delete this.animation;
2076  }
2077  /**
2078   * Destroy and clean up subscribers to this `MotionValue`.
2079   *
2080   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
2081   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
2082   * created a `MotionValue` via the `motionValue` function.
2083   *
2084   * @public
2085   */
2086  destroy() {
2087    this.dependents?.clear(), this.events.destroy?.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
2088  }
2089}
2090function Ue(t, e) {
2091  return new Bn(t, e);
2092}
2093const { schedule: z5 } = /* @__PURE__ */ Ms(queueMicrotask, !1), Ze = {
2094  x: !1,
2095  y: !1
2096};
2097function Hs() {
2098  return Ze.x || Ze.y;
2099}
2100function kn(t) {
2101  return t === "x" || t === "y" ? Ze[t] ? null : (Ze[t] = !0, () => {
2102    Ze[t] = !1;
2103  }) : Ze.x || Ze.y ? null : (Ze.x = Ze.y = !0, () => {
2104    Ze.x = Ze.y = !1;
2105  });
2106}
2107function Zs(t, e) {
2108  const s = R5(t), r = new AbortController(), n = {
2109    passive: !0,
2110    ...e,
2111    signal: r.signal
2112  };
2113  return [s, n, () => r.abort()];
2114}
2115function I0(t) {
2116  return !(t.pointerType === "touch" || Hs());
2117}
2118function An(t, e, s = {}) {
2119  const [r, n, o] = Zs(t, s), L = (d) => {
2120    if (!I0(d))
2121      return;
2122    const { target: l } = d, g = e(l, d);
2123    if (typeof g != "function" || !l)
2124      return;
2125    const f = (p) => {
2126      I0(p) && (g(p), l.removeEventListener("pointerleave", f));
2127    };
2128    l.addEventListener("pointerleave", f, n);
2129  };
2130  return r.forEach((d) => {
2131    d.addEventListener("pointerenter", L, n);
2132  }), o;
2133}
2134const Ws = (t, e) => e ? t === e ? !0 : Ws(t, e.parentElement) : !1, j5 = (t) => t.pointerType === "mouse" ? typeof t.button != "number" || t.button <= 0 : t.isPrimary !== !1, Nn = /* @__PURE__ */ new Set([
2135  "BUTTON",
2136  "INPUT",
2137  "SELECT",
2138  "TEXTAREA",
2139  "A"
2140]);
2141function In(t) {
2142  return Nn.has(t.tagName) || t.tabIndex !== -1;
2143}
2144const J2 = /* @__PURE__ */ new WeakSet();
2145function P0(t) {
2146  return (e) => {
2147    e.key === "Enter" && t(e);
2148  };
2149}
2150function Q3(t, e) {
2151  t.dispatchEvent(new PointerEvent("pointer" + e, { isPrimary: !0, bubbles: !0 }));
2152}
2153const Pn = (t, e) => {
2154  const s = t.currentTarget;
2155  if (!s)
2156    return;
2157  const r = P0(() => {
2158    if (J2.has(s))
2159      return;
2160    Q3(s, "down");
2161    const n = P0(() => {
2162      Q3(s, "up");
2163    }), o = () => Q3(s, "cancel");
2164    s.addEventListener("keyup", n, e), s.addEventListener("blur", o, e);
2165  });
2166  s.addEventListener("keydown", r, e), s.addEventListener("blur", () => s.removeEventListener("keydown", r), e);
2167};
2168function C0(t) {
2169  return j5(t) && !Hs();
2170}
2171function Cn(t, e, s = {}) {
2172  const [r, n, o] = Zs(t, s), L = (d) => {
2173    const l = d.currentTarget;
2174    if (!C0(d))
2175      return;
2176    J2.add(l);
2177    const g = e(l, d), f = (u, h) => {
2178      window.removeEventListener("pointerup", p), window.removeEventListener("pointercancel", M), J2.has(l) && J2.delete(l), C0(u) && typeof g == "function" && g(u, { success: h });
2179    }, p = (u) => {
2180      f(u, l === window || l === document || s.useGlobalTarget || Ws(l, u.target));
2181    }, M = (u) => {
2182      f(u, !1);
2183    };
2184    window.addEventListener("pointerup", p, n), window.addEventListener("pointercancel", M, n);
2185  };
2186  return r.forEach((d) => {
2187    (s.useGlobalTarget ? window : d).addEventListener("pointerdown", L, n), D5(d) && (d.addEventListener("focus", (g) => Pn(g, n)), !In(d) && !d.hasAttribute("tabindex") && (d.tabIndex = 0));
2188  }), o;
2189}
2190function O5(t) {
2191  return ss(t) && "ownerSVGElement" in t;
2192}
2193const K2 = /* @__PURE__ */ new WeakMap();
2194let Y2;
2195const $s = (t, e, s) => (r, n) => n && n[0] ? n[0][t + "Size"] : O5(r) && "getBBox" in r ? r.getBBox()[e] : r[s], Fn