https://pixel-leaves-34276573.figma.site/_components/v2/6cc76248e0339c4d864e41e7d123686a81bb3c73.js

1const Dd = (t) => import(t), Rd = () => Promise.resolve().then(() => Ed), { Fragment: Ge, jsx: f, jsxs: w } = globalThis.__GLOBALS__.ReactJSXRuntime;
2"use" in globalThis.__GLOBALS__.React || (globalThis.__GLOBALS__.React.use = () => {
3  throw new Error("`use` is not available in this version of React. Make currently only supports React 18, but `use` is only available in React 19+.");
4});
5const To = globalThis.__GLOBALS__.React, { Children: So, cloneElement: Po, Component: Ci, createContext: Ft, createElement: ye, createFactory: Nd, createRef: Ld, forwardRef: yn, Fragment: Mi, isValidElement: Co, lazy: Id, memo: Fd, Profiler: Bd, PureComponent: Od, startTransition: jd, StrictMode: $d, Suspense: Ud, use: _d, useCallback: xn, useContext: z, useDebugValue: Wd, useDeferredValue: zd, useEffect: G, useId: vn, useImperativeHandle: Hd, useInsertionEffect: Ai, useLayoutEffect: Mo, useMemo: mt, useReducer: Kd, useRef: rt, useState: D, useSyncExternalStore: Gd, useTransition: Xd, version: Yd } = globalThis.__GLOBALS__.React, bn = Ft({});
6function wn(t) {
7  const e = rt(null);
8  return e.current === null && (e.current = t()), e.current;
9}
10const Tn = typeof window < "u", ki = Tn ? Mo : G, Ce = /* @__PURE__ */ Ft(null);
11function Sn(t, e) {
12  t.indexOf(e) === -1 && t.push(e);
13}
14function Pn(t, e) {
15  const n = t.indexOf(e);
16  n > -1 && t.splice(n, 1);
17}
18const lt = (t, e, n) => n > e ? e : n < t ? t : n;
19let Cn = () => {
20};
21const ct = {}, Vi = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t);
22function Ei(t) {
23  return typeof t == "object" && t !== null;
24}
25const Di = (t) => /^0[^.\s]+$/u.test(t);
26// @__NO_SIDE_EFFECTS__
27function Mn(t) {
28  let e;
29  return () => (e === void 0 && (e = t()), e);
30}
31const nt = /* @__NO_SIDE_EFFECTS__ */ (t) => t, Ao = (t, e) => (n) => e(t(n)), se = (...t) => t.reduce(Ao), Zt = /* @__NO_SIDE_EFFECTS__ */ (t, e, n) => {
32  const s = e - t;
33  return s === 0 ? 1 : (n - t) / s;
34};
35class An {
36  constructor() {
37    this.subscriptions = [];
38  }
39  add(e) {
40    return Sn(this.subscriptions, e), () => Pn(this.subscriptions, e);
41  }
42  notify(e, n, s) {
43    const i = this.subscriptions.length;
44    if (i)
45      if (i === 1)
46        this.subscriptions[0](e, n, s);
47      else
48        for (let o = 0; o < i; o++) {
49          const r = this.subscriptions[o];
50          r && r(e, n, s);
51        }
52  }
53  getSize() {
54    return this.subscriptions.length;
55  }
56  clear() {
57    this.subscriptions.length = 0;
58  }
59}
60const ot = /* @__NO_SIDE_EFFECTS__ */ (t) => t * 1e3, et = /* @__NO_SIDE_EFFECTS__ */ (t) => t / 1e3;
61function Ri(t, e) {
62  return e ? t * (1e3 / e) : 0;
63}
64const Ni = (t, e, n) => (((1 - 3 * n + 3 * e) * t + (3 * n - 6 * e)) * t + 3 * e) * t, ko = 1e-7, Vo = 12;
65function Eo(t, e, n, s, i) {
66  let o, r, a = 0;
67  do
68    r = e + (n - e) / 2, o = Ni(r, s, i) - t, o > 0 ? n = r : e = r;
69  while (Math.abs(o) > ko && ++a < Vo);
70  return r;
71}
72function ie(t, e, n, s) {
73  if (t === e && n === s)
74    return nt;
75  const i = (o) => Eo(o, 0, 1, t, n);
76  return (o) => o === 0 || o === 1 ? o : Ni(i(o), e, s);
77}
78const Li = (t) => (e) => e <= 0.5 ? t(2 * e) / 2 : (2 - t(2 * (1 - e))) / 2, Ii = (t) => (e) => 1 - t(1 - e), Fi = /* @__PURE__ */ ie(0.33, 1.53, 0.69, 0.99), kn = /* @__PURE__ */ Ii(Fi), Bi = /* @__PURE__ */ Li(kn), Oi = (t) => (t *= 2) < 1 ? 0.5 * kn(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1))), Vn = (t) => 1 - Math.sin(Math.acos(t)), ji = Ii(Vn), $i = Li(Vn), Do = /* @__PURE__ */ ie(0.42, 0, 1, 1), Ro = /* @__PURE__ */ ie(0, 0, 0.58, 1), Ui = /* @__PURE__ */ ie(0.42, 0, 0.58, 1), No = (t) => Array.isArray(t) && typeof t[0] != "number", _i = (t) => Array.isArray(t) && typeof t[0] == "number", Lo = {
79  linear: nt,
80  easeIn: Do,
81  easeInOut: Ui,
82  easeOut: Ro,
83  circIn: Vn,
84  circInOut: $i,
85  circOut: ji,
86  backIn: kn,
87  backInOut: Bi,
88  backOut: Fi,
89  anticipate: Oi
90}, Io = (t) => typeof t == "string", ss = (t) => {
91  if (_i(t)) {
92    Cn(t.length === 4);
93    const [e, n, s, i] = t;
94    return ie(e, n, s, i);
95  } else if (Io(t))
96    return Lo[t];
97  return t;
98}, ce = [
99  "setup",
100  // Compute
101  "read",
102  // Read
103  "resolveKeyframes",
104  // Write/Read/Write/Read
105  "preUpdate",
106  // Compute
107  "update",
108  // Compute
109  "preRender",
110  // Compute
111  "render",
112  // Write
113  "postRender"
114  // Compute
115];
116function Fo(t, e) {
117  let n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), i = !1, o = !1;
118  const r = /* @__PURE__ */ new WeakSet();
119  let a = {
120    delta: 0,
121    timestamp: 0,
122    isProcessing: !1
123  };
124  function l(c) {
125    r.has(c) && (u.schedule(c), t()), c(a);
126  }
127  const u = {
128    /**
129     * Schedule a process to run on the next frame.
130     */
131    schedule: (c, h = !1, d = !1) => {
132      const p = d && i ? n : s;
133      return h && r.add(c), p.has(c) || p.add(c), c;
134    },
135    /**
136     * Cancel the provided callback from running on the next frame.
137     */
138    cancel: (c) => {
139      s.delete(c), r.delete(c);
140    },
141    /**
142     * Execute all schedule callbacks.
143     */
144    process: (c) => {
145      if (a = c, i) {
146        o = !0;
147        return;
148      }
149      i = !0, [n, s] = [s, n], n.forEach(l), n.clear(), i = !1, o && (o = !1, u.process(c));
150    }
151  };
152  return u;
153}
154const Bo = 40;
155function Wi(t, e) {
156  let n = !1, s = !0;
157  const i = {
158    delta: 0,
159    timestamp: 0,
160    isProcessing: !1
161  }, o = () => n = !0, r = ce.reduce((v, A) => (v[A] = Fo(o), v), {}), { setup: a, read: l, resolveKeyframes: u, preUpdate: c, update: h, preRender: d, render: m, postRender: p } = r, g = () => {
162    const v = ct.useManualTiming ? i.timestamp : performance.now();
163    n = !1, ct.useManualTiming || (i.delta = s ? 1e3 / 60 : Math.max(Math.min(v - i.timestamp, Bo), 1)), i.timestamp = v, i.isProcessing = !0, a.process(i), l.process(i), u.process(i), c.process(i), h.process(i), d.process(i), m.process(i), p.process(i), i.isProcessing = !1, n && e && (s = !1, t(g));
164  }, b = () => {
165    n = !0, s = !0, i.isProcessing || t(g);
166  };
167  return { schedule: ce.reduce((v, A) => {
168    const S = r[A];
169    return v[A] = (M, k = !1, C = !1) => (n || b(), S.schedule(M, k, C)), v;
170  }, {}), cancel: (v) => {
171    for (let A = 0; A < ce.length; A++)
172      r[ce[A]].cancel(v);
173  }, state: i, steps: r };
174}
175const { schedule: R, cancel: pt, state: _, steps: De } = /* @__PURE__ */ Wi(typeof requestAnimationFrame < "u" ? requestAnimationFrame : nt, !0);
176let fe;
177function Oo() {
178  fe = void 0;
179}
180const X = {
181  now: () => (fe === void 0 && X.set(_.isProcessing || ct.useManualTiming ? _.timestamp : performance.now()), fe),
182  set: (t) => {
183    fe = t, queueMicrotask(Oo);
184  }
185}, zi = (t) => (e) => typeof e == "string" && e.startsWith(t), En = /* @__PURE__ */ zi("--"), jo = /* @__PURE__ */ zi("var(--"), Dn = (t) => jo(t) ? $o.test(t.split("/*")[0].trim()) : !1, $o = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu, Bt = {
186  test: (t) => typeof t == "number",
187  parse: parseFloat,
188  transform: (t) => t
189}, Jt = {
190  ...Bt,
191  transform: (t) => lt(0, 1, t)
192}, ue = {
193  ...Bt,
194  default: 1
195}, Kt = (t) => Math.round(t * 1e5) / 1e5, Rn = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
196function Uo(t) {
197  return t == null;
198}
199const _o = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, Nn = (t, e) => (n) => !!(typeof n == "string" && _o.test(n) && n.startsWith(t) || e && !Uo(n) && Object.prototype.hasOwnProperty.call(n, e)), Hi = (t, e, n) => (s) => {
200  if (typeof s != "string")
201    return s;
202  const [i, o, r, a] = s.match(Rn);
203  return {
204    [t]: parseFloat(i),
205    [e]: parseFloat(o),
206    [n]: parseFloat(r),
207    alpha: a !== void 0 ? parseFloat(a) : 1
208  };
209}, Wo = (t) => lt(0, 255, t), Re = {
210  ...Bt,
211  transform: (t) => Math.round(Wo(t))
212}, wt = {
213  test: /* @__PURE__ */ Nn("rgb", "red"),
214  parse: /* @__PURE__ */ Hi("red", "green", "blue"),
215  transform: ({ red: t, green: e, blue: n, alpha: s = 1 }) => "rgba(" + Re.transform(t) + ", " + Re.transform(e) + ", " + Re.transform(n) + ", " + Kt(Jt.transform(s)) + ")"
216};
217function zo(t) {
218  let e = "", n = "", s = "", i = "";
219  return t.length > 5 ? (e = t.substring(1, 3), n = t.substring(3, 5), s = t.substring(5, 7), i = t.substring(7, 9)) : (e = t.substring(1, 2), n = t.substring(2, 3), s = t.substring(3, 4), i = t.substring(4, 5), e += e, n += n, s += s, i += i), {
220    red: parseInt(e, 16),
221    green: parseInt(n, 16),
222    blue: parseInt(s, 16),
223    alpha: i ? parseInt(i, 16) / 255 : 1
224  };
225}
226const Xe = {
227  test: /* @__PURE__ */ Nn("#"),
228  parse: zo,
229  transform: wt.transform
230}, re = /* @__NO_SIDE_EFFECTS__ */ (t) => ({
231  test: (e) => typeof e == "string" && e.endsWith(t) && e.split(" ").length === 1,
232  parse: parseFloat,
233  transform: (e) => `${e}${t}`
234}), ht = /* @__PURE__ */ re("deg"), at = /* @__PURE__ */ re("%"), P = /* @__PURE__ */ re("px"), Ho = /* @__PURE__ */ re("vh"), Ko = /* @__PURE__ */ re("vw"), is = {
235  ...at,
236  parse: (t) => at.parse(t) / 100,
237  transform: (t) => at.transform(t * 100)
238}, At = {
239  test: /* @__PURE__ */ Nn("hsl", "hue"),
240  parse: /* @__PURE__ */ Hi("hue", "saturation", "lightness"),
241  transform: ({ hue: t, saturation: e, lightness: n, alpha: s = 1 }) => "hsla(" + Math.round(t) + ", " + at.transform(Kt(e)) + ", " + at.transform(Kt(n)) + ", " + Kt(Jt.transform(s)) + ")"
242}, j = {
243  test: (t) => wt.test(t) || Xe.test(t) || At.test(t),
244  parse: (t) => wt.test(t) ? wt.parse(t) : At.test(t) ? At.parse(t) : Xe.parse(t),
245  transform: (t) => typeof t == "string" ? t : t.hasOwnProperty("red") ? wt.transform(t) : At.transform(t),
246  getAnimatableNone: (t) => {
247    const e = j.parse(t);
248    return e.alpha = 0, j.transform(e);
249  }
250}, Go = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
251function Xo(t) {
252  return isNaN(t) && typeof t == "string" && (t.match(Rn)?.length || 0) + (t.match(Go)?.length || 0) > 0;
253}
254const Ki = "number", Gi = "color", Yo = "var", qo = "var(", rs = "${}", Zo = /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;
255function Qt(t) {
256  const e = t.toString(), n = [], s = {
257    color: [],
258    number: [],
259    var: []
260  }, i = [];
261  let o = 0;
262  const a = e.replace(Zo, (l) => (j.test(l) ? (s.color.push(o), i.push(Gi), n.push(j.parse(l))) : l.startsWith(qo) ? (s.var.push(o), i.push(Yo), n.push(l)) : (s.number.push(o), i.push(Ki), n.push(parseFloat(l))), ++o, rs)).split(rs);
263  return { values: n, split: a, indexes: s, types: i };
264}
265function Xi(t) {
266  return Qt(t).values;
267}
268function Yi(t) {
269  const { split: e, types: n } = Qt(t), s = e.length;
270  return (i) => {
271    let o = "";
272    for (let r = 0; r < s; r++)
273      if (o += e[r], i[r] !== void 0) {
274        const a = n[r];
275        a === Ki ? o += Kt(i[r]) : a === Gi ? o += j.transform(i[r]) : o += i[r];
276      }
277    return o;
278  };
279}
280const Jo = (t) => typeof t == "number" ? 0 : j.test(t) ? j.getAnimatableNone(t) : t;
281function Qo(t) {
282  const e = Xi(t);
283  return Yi(t)(e.map(Jo));
284}
285const gt = {
286  test: Xo,
287  parse: Xi,
288  createTransformer: Yi,
289  getAnimatableNone: Qo
290};
291function Ne(t, e, n) {
292  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? t + (e - t) * 6 * n : n < 1 / 2 ? e : n < 2 / 3 ? t + (e - t) * (2 / 3 - n) * 6 : t;
293}
294function ta({ hue: t, saturation: e, lightness: n, alpha: s }) {
295  t /= 360, e /= 100, n /= 100;
296  let i = 0, o = 0, r = 0;
297  if (!e)
298    i = o = r = n;
299  else {
300    const a = n < 0.5 ? n * (1 + e) : n + e - n * e, l = 2 * n - a;
301    i = Ne(l, a, t + 1 / 3), o = Ne(l, a, t), r = Ne(l, a, t - 1 / 3);
302  }
303  return {
304    red: Math.round(i * 255),
305    green: Math.round(o * 255),
306    blue: Math.round(r * 255),
307    alpha: s
308  };
309}
310function xe(t, e) {
311  return (n) => n > 0 ? e : t;
312}
313const N = (t, e, n) => t + (e - t) * n, Le = (t, e, n) => {
314  const s = t * t, i = n * (e * e - s) + s;
315  return i < 0 ? 0 : Math.sqrt(i);
316}, ea = [Xe, wt, At], na = (t) => ea.find((e) => e.test(t));
317function os(t) {
318  const e = na(t);
319  if (!e)
320    return !1;
321  let n = e.parse(t);
322  return e === At && (n = ta(n)), n;
323}
324const as = (t, e) => {
325  const n = os(t), s = os(e);
326  if (!n || !s)
327    return xe(t, e);
328  const i = { ...n };
329  return (o) => (i.red = Le(n.red, s.red, o), i.green = Le(n.green, s.green, o), i.blue = Le(n.blue, s.blue, o), i.alpha = N(n.alpha, s.alpha, o), wt.transform(i));
330}, Ye = /* @__PURE__ */ new Set(["none", "hidden"]);
331function sa(t, e) {
332  return Ye.has(t) ? (n) => n <= 0 ? t : e : (n) => n >= 1 ? e : t;
333}
334function ia(t, e) {
335  return (n) => N(t, e, n);
336}
337function Ln(t) {
338  return typeof t == "number" ? ia : typeof t == "string" ? Dn(t) ? xe : j.test(t) ? as : aa : Array.isArray(t) ? qi : typeof t == "object" ? j.test(t) ? as : ra : xe;
339}
340function qi(t, e) {
341  const n = [...t], s = n.length, i = t.map((o, r) => Ln(o)(o, e[r]));
342  return (o) => {
343    for (let r = 0; r < s; r++)
344      n[r] = i[r](o);
345    return n;
346  };
347}
348function ra(t, e) {
349  const n = { ...t, ...e }, s = {};
350  for (const i in n)
351    t[i] !== void 0 && e[i] !== void 0 && (s[i] = Ln(t[i])(t[i], e[i]));
352  return (i) => {
353    for (const o in s)
354      n[o] = s[o](i);
355    return n;
356  };
357}
358function oa(t, e) {
359  const n = [], s = { color: 0, var: 0, number: 0 };
360  for (let i = 0; i < e.values.length; i++) {
361    const o = e.types[i], r = t.indexes[o][s[o]], a = t.values[r] ?? 0;
362    n[i] = a, s[o]++;
363  }
364  return n;
365}
366const aa = (t, e) => {
367  const n = gt.createTransformer(e), s = Qt(t), i = Qt(e);
368  return s.indexes.var.length === i.indexes.var.length && s.indexes.color.length === i.indexes.color.length && s.indexes.number.length >= i.indexes.number.length ? Ye.has(t) && !i.values.length || Ye.has(e) && !s.values.length ? sa(t, e) : se(qi(oa(s, i), i.values), n) : xe(t, e);
369};
370function Zi(t, e, n) {
371  return typeof t == "number" && typeof e == "number" && typeof n == "number" ? N(t, e, n) : Ln(t)(t, e);
372}
373const la = (t) => {
374  const e = ({ timestamp: n }) => t(n);
375  return {
376    start: (n = !0) => R.update(e, n),
377    stop: () => pt(e),
378    /**
379     * If we're processing this frame we can use the
380     * framelocked timestamp to keep things in sync.
381     */
382    now: () => _.isProcessing ? _.timestamp : X.now()
383  };
384}, Ji = (t, e, n = 10) => {
385  let s = "";
386  const i = Math.max(Math.round(e / n), 2);
387  for (let o = 0; o < i; o++)
388    s += Math.round(t(o / (i - 1)) * 1e4) / 1e4 + ", ";
389  return `linear(${s.substring(0, s.length - 2)})`;
390}, ve = 2e4;
391function In(t) {
392  let e = 0;
393  const n = 50;
394  let s = t.next(e);
395  for (; !s.done && e < ve; )
396    e += n, s = t.next(e);
397  return e >= ve ? 1 / 0 : e;
398}
399function ca(t, e = 100, n) {
400  const s = n({ ...t, keyframes: [0, e] }), i = Math.min(In(s), ve);
401  return {
402    type: "keyframes",
403    ease: (o) => s.next(i * o).value / e,
404    duration: /* @__PURE__ */ et(i)
405  };
406}
407const ua = 5;
408function Qi(t, e, n) {
409  const s = Math.max(e - ua, 0);
410  return Ri(n - t(s), e - s);
411}
412const L = {
413  // Default spring physics
414  stiffness: 100,
415  damping: 10,
416  mass: 1,
417  velocity: 0,
418  // Default duration/bounce-based options
419  duration: 800,
420  // in ms
421  bounce: 0.3,
422  visualDuration: 0.3,
423  // in seconds
424  // Rest thresholds
425  restSpeed: {
426    granular: 0.01,
427    default: 2
428  },
429  restDelta: {
430    granular: 5e-3,
431    default: 0.5
432  },
433  // Limits
434  minDuration: 0.01,
435  // in seconds
436  maxDuration: 10,
437  // in seconds
438  minDamping: 0.05,
439  maxDamping: 1
440}, Ie = 1e-3;
441function ha({ duration: t = L.duration, bounce: e = L.bounce, velocity: n = L.velocity, mass: s = L.mass }) {
442  let i, o, r = 1 - e;
443  r = lt(L.minDamping, L.maxDamping, r), t = lt(L.minDuration, L.maxDuration, /* @__PURE__ */ et(t)), r < 1 ? (i = (u) => {
444    const c = u * r, h = c * t, d = c - n, m = qe(u, r), p = Math.exp(-h);
445    return Ie - d / m * p;
446  }, o = (u) => {
447    const h = u * r * t, d = h * n + n, m = Math.pow(r, 2) * Math.pow(u, 2) * t, p = Math.exp(-h), g = qe(Math.pow(u, 2), r);
448    return (-i(u) + Ie > 0 ? -1 : 1) * ((d - m) * p) / g;
449  }) : (i = (u) => {
450    const c = Math.exp(-u * t), h = (u - n) * t + 1;
451    return -Ie + c * h;
452  }, o = (u) => {
453    const c = Math.exp(-u * t), h = (n - u) * (t * t);
454    return c * h;
455  });
456  const a = 5 / t, l = fa(i, o, a);
457  if (t = /* @__PURE__ */ ot(t), isNaN(l))
458    return {
459      stiffness: L.stiffness,
460      damping: L.damping,
461      duration: t
462    };
463  {
464    const u = Math.pow(l, 2) * s;
465    return {
466      stiffness: u,
467      damping: r * 2 * Math.sqrt(s * u),
468      duration: t
469    };
470  }
471}
472const da = 12;
473function fa(t, e, n) {
474  let s = n;
475  for (let i = 1; i < da; i++)
476    s = s - t(s) / e(s);
477  return s;
478}
479function qe(t, e) {
480  return t * Math.sqrt(1 - e * e);
481}
482const ma = ["duration", "bounce"], pa = ["stiffness", "damping", "mass"];
483function ls(t, e) {
484  return e.some((n) => t[n] !== void 0);
485}
486function ga(t) {
487  let e = {
488    velocity: L.velocity,
489    stiffness: L.stiffness,
490    damping: L.damping,
491    mass: L.mass,
492    isResolvedFromDuration: !1,
493    ...t
494  };
495  if (!ls(t, pa) && ls(t, ma))
496    if (t.visualDuration) {
497      const n = t.visualDuration, s = 2 * Math.PI / (n * 1.2), i = s * s, o = 2 * lt(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(i);
498      e = {
499        ...e,
500        mass: L.mass,
501        stiffness: i,
502        damping: o
503      };
504    } else {
505      const n = ha(t);
506      e = {
507        ...e,
508        ...n,
509        mass: L.mass
510      }, e.isResolvedFromDuration = !0;
511    }
512  return e;
513}
514function be(t = L.visualDuration, e = L.bounce) {
515  const n = typeof t != "object" ? {
516    visualDuration: t,

517    keyframes: [0, 1],
518    bounce: e
519  } : t;
520  let { restSpeed: s, restDelta: i } = n;
521  const o = n.keyframes[0], r = n.keyframes[n.keyframes.length - 1], a = { done: !1, value: o }, { stiffness: l, damping: u, mass: c, duration: h, velocity: d, isResolvedFromDuration: m } = ga({
522    ...n,
523    velocity: -/* @__PURE__ */ et(n.velocity || 0)
524  }), p = d || 0, g = u / (2 * Math.sqrt(l * c)), b = r - o, y = /* @__PURE__ */ et(Math.sqrt(l / c)), x = Math.abs(b) < 5;
525  s || (s = x ? L.restSpeed.granular : L.restSpeed.default), i || (i = x ? L.restDelta.granular : L.restDelta.default);
526  let v;
527  if (g < 1) {
528    const S = qe(y, g);
529    v = (M) => {
530      const k = Math.exp(-g * y * M);
531      return r - k * ((p + g * y * b) / S * Math.sin(S * M) + b * Math.cos(S * M));
532    };
533  } else if (g === 1)
534    v = (S) => r - Math.exp(-y * S) * (b + (p + y * b) * S);
535  else {
536    const S = y * Math.sqrt(g * g - 1);
537    v = (M) => {
538      const k = Math.exp(-g * y * M), C = Math.min(S * M, 300);
539      return r - k * ((p + g * y * b) * Math.sinh(C) + S * b * Math.cosh(C)) / S;
540    };
541  }
542  const A = {
543    calculatedDuration: m && h || null,
544    next: (S) => {
545      const M = v(S);
546      if (m)
547        a.done = S >= h;
548      else {
549        let k = S === 0 ? p : 0;
550        g < 1 && (k = S === 0 ? /* @__PURE__ */ ot(p) : Qi(v, S, M));
551        const C = Math.abs(k) <= s, B = Math.abs(r - M) <= i;
552        a.done = C && B;
553      }
554      return a.value = a.done ? r : M, a;
555    },
556    toString: () => {
557      const S = Math.min(In(A), ve), M = Ji((k) => A.next(S * k).value, S, 30);
558      return S + "ms " + M;
559    },
560    toTransition: () => {
561    }
562  };
563  return A;
564}
565be.applyToOptions = (t) => {
566  const e = ca(t, 100, be);
567  return t.ease = e.ease, t.duration = /* @__PURE__ */ ot(e.duration), t.type = "keyframes", t;
568};
569function Ze({ keyframes: t, velocity: e = 0, power: n = 0.8, timeConstant: s = 325, bounceDamping: i = 10, bounceStiffness: o = 500, modifyTarget: r, min: a, max: l, restDelta: u = 0.5, restSpeed: c }) {
570  const h = t[0], d = {
571    done: !1,
572    value: h
573  }, m = (C) => a !== void 0 && C < a || l !== void 0 && C > l, p = (C) => a === void 0 ? l : l === void 0 || Math.abs(a - C) < Math.abs(l - C) ? a : l;
574  let g = n * e;
575  const b = h + g, y = r === void 0 ? b : r(b);
576  y !== b && (g = y - h);
577  const x = (C) => -g * Math.exp(-C / s), v = (C) => y + x(C), A = (C) => {
578    const B = x(C), $ = v(C);
579    d.done = Math.abs(B) <= u, d.value = d.done ? y : $;
580  };
581  let S, M;
582  const k = (C) => {
583    m(d.value) && (S = C, M = be({
584      keyframes: [d.value, p(d.value)],
585      velocity: Qi(v, C, d.value),
586      // TODO: This should be passing * 1000
587      damping: i,
588      stiffness: o,
589      restDelta: u,
590      restSpeed: c
591    }));
592  };
593  return k(0), {
594    calculatedDuration: null,
595    next: (C) => {
596      let B = !1;
597      return !M && S === void 0 && (B = !0, A(C), k(C)), S !== void 0 && C >= S ? M.next(C - S) : (!B && A(C), d);
598    }
599  };
600}
601function ya(t, e, n) {
602  const s = [], i = n || ct.mix || Zi, o = t.length - 1;
603  for (let r = 0; r < o; r++) {
604    let a = i(t[r], t[r + 1]);
605    if (e) {
606      const l = Array.isArray(e) ? e[r] || nt : e;
607      a = se(l, a);
608    }
609    s.push(a);
610  }
611  return s;
612}
613function xa(t, e, { clamp: n = !0, ease: s, mixer: i } = {}) {
614  const o = t.length;
615  if (Cn(o === e.length), o === 1)
616    return () => e[0];
617  if (o === 2 && e[0] === e[1])
618    return () => e[1];
619  const r = t[0] === t[1];
620  t[0] > t[o - 1] && (t = [...t].reverse(), e = [...e].reverse());
621  const a = ya(e, s, i), l = a.length, u = (c) => {
622    if (r && c < t[0])
623      return e[0];
624    let h = 0;
625    if (l > 1)
626      for (; h < t.length - 2 && !(c < t[h + 1]); h++)
627        ;
628    const d = /* @__PURE__ */ Zt(t[h], t[h + 1], c);
629    return a[h](d);
630  };
631  return n ? (c) => u(lt(t[0], t[o - 1], c)) : u;
632}
633function va(t, e) {
634  const n = t[t.length - 1];
635  for (let s = 1; s <= e; s++) {
636    const i = /* @__PURE__ */ Zt(0, e, s);
637    t.push(N(n, 1, i));
638  }
639}
640function ba(t) {
641  const e = [0];
642  return va(e, t.length - 1), e;
643}
644function wa(t, e) {
645  return t.map((n) => n * e);
646}
647function Ta(t, e) {
648  return t.map(() => e || Ui).splice(0, t.length - 1);
649}
650function Gt({ duration: t = 300, keyframes: e, times: n, ease: s = "easeInOut" }) {
651  const i = No(s) ? s.map(ss) : ss(s), o = {
652    done: !1,
653    value: e[0]
654  }

654, r = wa(
655    // Only use the provided offsets if they're the correct length
656    // TODO Maybe we should warn here if there's a length mismatch
657    n && n.length === e.length ? n : ba(e),
658    t
659  ), a = xa(r, e, {
660    ease: Array.isArray(i) ? i : Ta(e, i)
661  });
662  return {
663    calculatedDuration: t,
664    next: (l) => (o.value = a(l), o.done = l >= t, o)
665  };
666}
667const Sa = (t) => t !== null;
668function Fn(t, { repeat: e, repeatType: n = "loop" }, s, i = 1) {
669  const o = t.filter(Sa), a = i < 0 || e && n !== "loop" && e % 2 === 1 ? 0 : o.length - 1;
670  return !a || s === void 0 ? o[a] : s;
671}
672const Pa = {
673  decay: Ze,
674  inertia: Ze,
675  tween: Gt,
676  keyframes: Gt,
677  spring: be
678};
679function tr(t) {
680  typeof t.type == "string" && (t.type = Pa[t.type]);
681}
682class Bn {
683  constructor() {
684    this.updateFinished();
685  }
686  get finished() {
687    return this._finished;
688  }
689  updateFinished() {
690    this._finished = new Promise((e) => {
691      this.resolve = e;
692    });
693  }
694  notifyFinished() {
695    this.resolve();
696  }
697  /**
698   * Allows the animation to be awaited.
699   *
700   * @deprecated Use `finished` instead.
701   */
702  then(e, n) {
703    return this.finished.then(e, n);
704  }
705}
706const Ca = (t) => t / 100;
707class On extends Bn {
708  constructor(e) {
709    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
710      const { motionValue: n } = this.options;
711      n && n.updatedAt !== X.now() && this.tick(X.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
712    }, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
713  }
714  initAnimation() {
715    const { options: e } = this;
716    tr(e);
717    const { type: n = Gt, repeat: s = 0, repeatDelay: i = 0, repeatType: o, velocity: r = 0 } = e;
718    let { keyframes: a } = e;
719    const l = n || Gt;
720    l !== Gt && typeof a[0] != "number" && (this.mixKeyframes = se(Ca, Zi(a[0], a[1])), a = [0, 100]);
721    const u = l({ ...e, keyframes: a });
722    o === "mirror" && (this.mirroredGenerator = l({
723      ...e,
724      keyframes: [...a].reverse(),
725      velocity: -r
726    })), u.calculatedDuration === null && (u.calculatedDuration = In(u));
727    const { calculatedDuration: c } = u;
728    this.calculatedDuration = c, this.resolvedDuration = c + i, this.totalDuration = this.resolvedDuration * (s + 1) - i, this.generator = u;
729  }
730  updateTime(e) {
731    const n = Math.round(e - this.startTime) * this.playbackSpeed;
732    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = n;
733  }
734  tick(e, n = !1) {
735    const { generator: s, totalDuration: i, mixKeyframes: o, mirroredGenerator: r, resolvedDuration: a, calculatedDuration: l } = this;
736    if (this.startTime === null)
737      return s.next(0);
738    const { delay: u = 0, keyframes: c, repeat: h, repeatType: d, repeatDelay: m, type: p, onUpdate: g, finalKeyframe: b } = this.options;
739    this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - i / this.speed, this.startTime)), n ? this.currentTime = e : this.updateTime(e);
740    const y = this.currentTime - u * (this.playbackSpeed >= 0 ? 1 : -1), x = this.playbackSpeed >= 0 ? y < 0 : y > i;
741    this.currentTime = Math.max(y, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = i);
742    let v = this.currentTime, A = s;
743    if (h) {
744      const C = Math.min(this.currentTime, i) / a;
745      let B = Math.floor(C), $ = C % 1;
746      !$ && C >= 1 && ($ = 1), $ === 1 && B--, B = Math.min(B, h + 1), !!(B % 2) && (d === "reverse" ? ($ = 1 - $, m && ($ -= m / a)) : d === "mirror" && (A = r)), v = lt(0, 1, $) * a;
747    }
748    const S = x ? { done: !1, value: c[0] } : A.next(v);
749    o && (S.value = o(S.value));
750    let { done: M } = S;
751    !x && l !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= i : this.currentTime <= 0);
752    const k = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
753    return k && p !== Ze && (S.value = Fn(c, this.options, b, this.speed)), g && g(S.value), k && this.finish(), S;
754  }
755  /**
756   * Allows the returned animation to be awaited or promise-chained. Currently
757   * resolves when the animation finishes at all but in a future update could/should
758   * reject if its cancels.
759   */
760  then(e, n) {
761    return this.finished.then(e, n);
762  }
763  get duration() {
764    return /* @__PURE__ */ et(this.calculatedDuration);
765  }
766  get iterationDuration() {
767    const { delay: e = 0 } = this.options || {};
768    return this.duration + /* @__PURE__ */ et(e);
769  }
770  get time() {
771    return /* @__PURE__ */ et(this.currentTime);
772  }
773  set time(e) {
774    e = /* @__PURE__ */ ot(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);
775  }
776  get speed() {
777    return this.playbackSpeed;
778  }
779  set speed(e) {
780    this.updateTime(X.now());
781    const n = this.playbackSpeed !== e;
782    this.playbackSpeed = e, n && (this.time = /* @__PURE__ */ et(this.currentTime));
783  }
784  play() {
785    if (this.isStopped)
786      return;
787    const { driver: e = la, startTime: n } = this.options;
788    this.driver || (this.driver = e((i) => this.tick(i))), this.options.onPlay?.();
789    const s = this.driver.now();
790    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = n ?? s), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
791  }
792  pause() {
793    this.state = "paused", this.updateTime(X.now()), this.holdTime = this.currentTime;
794  }
795  complete() {
796    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
797  }
798  finish() {
799    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
800  }
801  cancel() {
802    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
803  }
804  teardown() {
805    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
806  }
807  stopDriver() {
808    this.driver && (this.driver.stop(), this.driver = void 0);
809  }
810  sample(e) {
811    return this.startTime = 0, this.tick(e, !0);
812  }
813  attachTimeline(e) {
814    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), e.observe(this);
815  }
816}
817function Ma(t) {
818  for (let e = 1; e < t.length; e++)
819    t[e] ?? (t[e] = t[e - 1]);
820}
821const Tt = (t) => t * 180 / Math.PI, Je = (t) => {
822  const e = Tt(Math.atan2(t[1], t[0]));
823  return Qe(e);
824}, Aa = {
825  x: 4,
826  y: 5,
827  translateX: 4,
828  translateY: 5,
829  scaleX: 0,
830  scaleY: 3,
831  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
832  rotate: Je,
833  rotateZ: Je,
834  skewX: (t) => Tt(Math.atan(t[1])),
835  skewY: (t) => Tt(Math.atan(t[2])),
836  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
837}, Qe = (t) => (t = t % 360, t < 0 && (t += 360), t), cs = Je, us = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), hs = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), ka = {
838  x: 12,
839  y: 13,
840  z: 14,
841  translateX: 12,
842  translateY: 13,
843  translateZ: 14,
844  scaleX: us,
845  scaleY: hs,
846  scale: (t) => (us(t) + hs(t)) / 2,
847  rotateX: (t) => Qe(Tt(Math.atan2(t[6], t[5]))),
848  rotateY: (t) => Qe(Tt(Math.atan2(-t[2], t[0]))),
849  rotateZ: cs,
850  rotate: cs,
851  skewX: (t) => Tt(Math.atan(t[4])),
852  skewY: (t) => Tt(Math.atan(t[1])),
853  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
854};
855function tn(t) {
856  return t.includes("scale") ? 1 : 0;
857}
858function en(t, e) {
859  if (!t || t === "none")
860    return tn(e);
861  const n = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
862  let s, i;
863  if (n)
864    s = ka, i = n;
865  else {
866    const a = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
867    s = Aa, i = a;
868  }
869  if (!i)
870    return tn(e);
871  const o = s[e], r = i[1].split(",").map(Ea);
872  return typeof o == "function" ? o(r) : r[o];
873}
874const Va = (t, e) => {
875  const { transform: n = "none" } = getComputedStyle(t);
876  return en(n, e);
877};
878function Ea(t) {
879  return parseFloat(t.trim());
880}
881const Ot = [
882  "transformPerspective",
883  "x",
884  "y",
885  "z",
886  "translateX",
887  "translateY",
888  "translateZ",
889  "scale",
890  "scaleX",
891  "scaleY",
892  "rotate",
893  "rotateX",
894  "rotateY",
895  "rotateZ",
896  "skew",
897  "skewX",
898  "skewY"
899], jt = new Set(Ot), ds = (t) => t === Bt || t === P, Da = /* @__PURE__ */ new Set(["x", "y", "z"]), Ra = Ot.filter((t) => !Da.has(t));
900function Na(t) {
901  const e = [];
902  return Ra.forEach((n) => {
903    const s = t.getValue(n);
904    s !== void 0 && (e.push([n, s.get()]), s.set(n.startsWith("scale") ? 1 : 0));
905  }), e;
906}
907const St = {
908  // Dimensions
909  width: ({ x: t }, { paddingLeft: e = "0", paddingRight: n = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(n),
910  height: ({ y: t }, { paddingTop: e = "0", paddingBottom: n = "0" }) => t.max - t.min - parseFloat(e) - parseFloat(n),
911  top: (t, { top: e }) => parseFloat(e),
912  left: (t, { left: e }) => parseFloat(e),
913  bottom: ({ y: t }, { top: e }) => parseFloat(e) + (t.max - t.min),
914  right: ({ x: t }, { left: e }) => parseFloat(e) + (t.max - t.min),
915  // Transform
916  x: (t, { transform: e }) => en(e, "x"),
917  y: (t, { transform: e }) => en(e, "y")
918};
919St.translateX = St.x;
920St.translateY = St.y;
921const Pt = /* @__PURE__ */ new Set();
922let nn = !1, sn = !1, rn = !1;
923function er() {
924  if (sn) {
925    const t = Array.from(Pt).filter((s) => s.needsMeasurement), e = new Set(t.map((s) => s.element)), n = /* @__PURE__ */ new Map();
926    e.forEach((s) => {
927      const i = Na(s);
928      i.length && (n.set(s, i), s.render());
929    }), t.forEach((s) => s.measureInitialState()), e.forEach((s) => {
930      s.render();
931      const i = n.get(s);
932      i && i.forEach(([o, r]) => {
933        s.getValue(o)?.set(r);
934      });
935    }), t.forEach((s) => s.measureEndState()), t.forEach((s) => {
936      s.suspendedScrollY !== void 0 && window.scrollTo(0, s.suspendedScrollY);
937    });
938  }
939  sn = !1, nn = !1, Pt.forEach((t) => t.complete(rn)), Pt.clear();
940}
941function nr() {
942  Pt.forEach((t) => {
943    t.readKeyframes(), t.needsMeasurement && (sn = !0);
944  });
945}
946function La() {
947  rn = !0, nr(), er(), rn = !1;
948}
949class jn {
950  constructor(e, n, s, i, o, r = !1) {
951    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...e], this.onComplete = n, this.name = s, this.motionValue = i, this.element = o, this.isAsync = r;
952  }
953  scheduleResolve() {
954    this.state = "scheduled", this.isAsync ? (Pt.add(this), nn || (nn = !0, R.read(nr), R.resolveKeyframes(er))) : (this.readKeyframes(), this.complete());
955  }
956  readKeyframes() {
957    const { unresolvedKeyframes: e, name: n, element: s, motionValue: i } = this;
958    if (e[0] === null) {
959      const o = i?.get(), r = e[e.length - 1];
960      if (o !== void 0)
961        e[0] = o;
962      else if (s && n) {
963        const a = s.readValue(n, r);
964        a != null && (e[0] = a);
965      }
966      e[0] === void 0 && (e[0] = r), i && o === void 0 && i.set(e[0]);
967    }
968    Ma(e);
969  }
970  setFinalKeyframe() {
971  }
972  measureInitialState() {
973  }
974  renderEndStyles() {
975  }
976  measureEndState() {
977  }
978  complete(e = !1) {
979    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, e), Pt.delete(this);
980  }
981  cancel() {
982    this.state === "scheduled" && (Pt.delete(this), this.state = "pending");
983  }
984  resume() {
985    this.state === "pending" && this.scheduleResolve();
986  }
987}
988const Ia = (t) => t.startsWith("--");
989function Fa(t, e, n) {
990  Ia(e) ? t.style.setProperty(e, n) : t.style[e] = n;
991}
992const Ba = /* @__PURE__ */ Mn(() => window.ScrollTimeline !== void 0), Oa = {};
993function ja(t, e) {
994  const n = /* @__PURE__ */ Mn(t);
995  return () => Oa[e] ?? n();
996}
997const sr = /* @__PURE__ */ ja(() => {
998  try {
999    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
1000  } catch {
1001    return !1;
1002  }
1003  return !0;
1004}, "linearEasing"), Ht = ([t, e, n, s]) => `cubic-bezier(${t}, ${e}, ${n}, ${s})`, fs = {
1005  linear: "linear",
1006  ease: "ease",
1007  easeIn: "ease-in",
1008  easeOut: "ease-out",
1009  easeInOut: "ease-in-out",
1010  circIn: /* @__PURE__ */ Ht([0, 0.65, 0.55, 1]),
1011  circOut: /* @__PURE__ */ Ht([0.55, 0, 1, 0.45]),
1012  backIn: /* @__PURE__ */ Ht([0.31, 0.01, 0.66, -0.59]),
1013  backOut: /* @__PURE__ */ Ht([0.33, 1.53, 0.69, 0.99])
1014};
1015function ir(t, e) {
1016  if (t)
1017    return typeof t == "function" ? sr() ? Ji(t, e) : "ease-out" : _i(t) ? Ht(t) : Array.isArray(t) ? t.map((n) => ir(n, e) || fs.easeOut) : fs[t];
1018}
1019function $a(t, e, n, { delay: s = 0, duration: i = 300, repeat: o = 0, repeatType: r = "loop", ease: a = "easeOut", times: l } = {}, u = void 0) {
1020  const c = {
1021    [e]: n
1022  };
1023  l && (c.offset = l);
1024  const h = ir(a, i);
1025  Array.isArray(h) && (c.easing = h);
1026  const d = {
1027    delay: s,
1028    duration: i,
1029    easing: Array.isArray(h) ? "linear" : h,

1345  const [s] = n.match(Rn) || [];
1346  if (!s)
1347    return t;
1348  const i = n.replace(s, "");
1349  let o = sl.has(e) ? 1 : 0;
1350  return s !== n && (o *= 100), e + "(" + o + i + ")";
1351}
1352const rl = /\b([a-z-]*)\(.*?\)/gu, an = {
1353  ...gt,
1354  getAnimatableNone: (t) => {
1355    const e = t.match(rl);
1356    return e ? e.map(il).join(" ") : t;
1357  }
1358}, ys = {
1359  ...Bt,
1360  transform: Math.round
1361}, ol = {
1362  rotate: ht,
1363  rotateX: ht,
1364  rotateY: ht,
1365  rotateZ: ht,
1366  scale: ue,
1367  scaleX: ue,
1368  scaleY: ue,
1369  scaleZ: ue,
1370  skew: ht,
1371  skewX: ht,
1372  skewY: ht,
1373  distance: P,
1374  translateX: P,
1375  translateY: P,
1376  translateZ: P,
1377  x: P,
1378  y: P,
1379  z: P,
1380  perspective: P,
1381  transformPerspective: P,
1382  opacity: Jt,
1383  originX: is,
1384  originY: is,
1385  originZ: P
1386}, Un = {
1387  // Border props
1388  borderWidth: P,
1389  borderTopWidth: P,
1390  borderRightWidth: P,
1391  borderBottomWidth: P,
1392  borderLeftWidth: P,
1393  borderRadius: P,
1394  radius: P,
1395  borderTopLeftRadius: P,
1396  borderTopRightRadius: P,
1397  borderBottomRightRadius: P,
1398  borderBottomLeftRadius: P,
1399  // Positioning props
1400  width: P,
1401  maxWidth: P,
1402  height: P,
1403  maxHeight: P,
1404  top: P,
1405  right: P,
1406  bottom: P,
1407  left: P,
1408  // Spacing props
1409  padding: P,
1410  paddingTop: P,
1411  paddingRight: P,
1412  paddingBottom: P,
1413  paddingLeft: P,
1414  margin: P,
1415  marginTop: P,
1416  marginRight: P,
1417  marginBottom: P,
1418  marginLeft: P,
1419  // Misc
1420  backgroundPositionX: P,
1421  backgroundPositionY: P,
1422  ...ol,
1423  zIndex: ys,
1424  // SVG
1425  fillOpacity: Jt,
1426  strokeOpacity: Jt,
1427  numOctaves: ys
1428}, al = {
1429  ...Un,
1430  // Color props
1431  color: j,
1432  backgroundColor: j,
1433  outlineColor: j,
1434  fill: j,
1435  stroke: j,
1436  // Border props
1437  borderColor: j,
1438  borderTopColor: j,
1439  borderRightColor: j,
1440  borderBottomColor: j,
1441  borderLeftColor: j,
1442  filter: an,
1443  WebkitFilter: an
1444}, hr = (t) => al[t];
1445function dr(t, e) {
1446  let n = hr(t);
1447  return n !== an && (n = gt), n.getAnimatableNone ? n.getAnimatableNone(e) : void 0;
1448}
1449const ll = /* @__PURE__ */ new Set(["auto", "none", "0"]);
1450function cl(t, e, n) {
1451  let s = 0, i;
1452  for (; s < t.length && !i; ) {
1453    const o = t[s];
1454    typeof o == "string" && !ll.has(o) && Qt(o).values.length && (i = t[s]), s++;
1455  }
1456  if (i && n)
1457    for (const o of e)
1458      t[o] = dr(n, i);
1459}
1460class ul extends jn {
1461  constructor(e, n, s, i, o) {
1462    super(e, n, s, i, o, !0);
1463  }
1464  readKeyframes() {
1465    const { unresolvedKeyframes: e, element: n, name: s } = this;
1466    if (!n || !n.current)
1467      return;
1468    super.readKeyframes();
1469    for (let l = 0; l < e.length; l++) {
1470      let u = e[l];
1471      if (typeof u == "string" && (u = u.trim(), Dn(u))) {
1472        const c = ar(u, n.current);
1473        c !== void 0 && (e[l] = c), l === e.length - 1 && (this.finalKeyframe = u);
1474      }
1475    }
1476    if (this.resolveNoneKeyframes(), !lr.has(s) || e.length !== 2)
1477      return;
1478    const [i, o] = e, r = gs(i), a = gs(o);
1479    if (r !== a)
1480      if (ds(r) && ds(a))
1481        for (let l = 0; l < e.length; l++) {
1482          const u = e[l];
1483          typeof u == "string" && (e[l] = parseFloat(u));
1484        }
1485      else St[s] && (this.needsMeasurement = !0);
1486  }
1487  resolveNoneKeyframes() {
1488    const { unresolvedKeyframes: e, name: n } = this, s = [];
1489    for (let i = 0; i < e.length; i++)
1490      (e[i] === null || nl(e[i])) && s.push(i);
1491    s.length && cl(e, s, n);
1492  }
1493  measureInitialState() {
1494    const { element: e, unresolvedKeyframes: n, name: s } = this;
1495    if (!e || !e.current)
1496      return;
1497    s === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = St[s](e.measureViewportBox(), window.getComputedStyle(e.current)), n[0] = this.measuredOrigin;
1498    const i = n[n.length - 1];
1499    i !== void 0 && e.getValue(s, i).jump(i, !1);
1500  }
1501  measureEndState() {
1502    const { element: e, name: n, unresolvedKeyframes: s } = this;
1503    if (!e || !e.current)
1504      return;
1505    const i = e.getValue(n);
1506    i && i.jump(this.measuredOrigin, !1);
1507    const o = s.length - 1, r = s[o];
1508    s[o] = St[n](e.measureViewportBox(), window.getComputedStyle(e.current)), r !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = r), this.removedTransforms?.length && this.removedTransforms.forEach(([a, l]) => {
1509      e.getValue(a).set(l);
1510    }), this.resolveNoneKeyframes();
1511  }
1512}
1513function hl(t, e, n) {
1514  if (t instanceof EventTarget)
1515    return [t];
1516  if (typeof t == "string") {
1517    let s = document;
1518    const i = n?.[t] ?? s.querySelectorAll(t);
1519    return i ? Array.from(i) : [];
1520  }
1521  return Array.from(t);
1522}
1523const fr = (t, e) => e && typeof t == "number" ? e.transform(t) : t;
1524function mr(t) {
1525  return Ei(t) && "offsetHeight" in t;
1526}
1527const xs = 30, dl = (t) => !isNaN(parseFloat(t));
1528class fl {
1529  /**
1530   * @param init - The initiating value
1531   * @param config - Optional configuration options
1532   *
1533   * -  `transformer`: A function to transform incoming values with.
1534   */
1535  constructor(e, n = {}) {
1536    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s) => {
1537      const i = X.now();
1538      if (this.updatedAt !== i && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && (this.events.change?.notify(this.current), this.dependents))
1539        for (const o of this.dependents)
1540          o.dirty();
1541    }, this.hasAnimated = !1, this.setCurrent(e), this.owner = n.owner;
1542  }
1543  setCurrent(e) {
1544    this.current = e, this.updatedAt = X.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = dl(this.current));
1545  }
1546  setPrevFrameValue(e = this.current) {
1547    this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt;
1548  }
1549  /**
1550   * Adds a function that will be notified when the `MotionValue` is updated.
1551   *
1552   * It returns a function that, when called, will cancel the subscription.
1553   *
1554   * When calling `onChange` inside a React component, it should be wrapped with the
1555   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
1556   * from the `useEffect` function to ensure you don't add duplicate subscribers..
1557   *
1558   * ```jsx
1559   * export const MyComponent = () => {
1560   *   const x = useMotionValue(0)
1561   *   const y = useMotionValue(0)
1562   *   const opacity = useMotionValue(1)
1563   *
1564   *   useEffect(() => {
1565   *     function updateOpacity() {
1566   *       const maxXY = Math.max(x.get(), y.get())
1567   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
1568   *       opacity.set(newOpacity)
1569   *     }
1570   *
1571   *     const unsubscribeX = x.on("change", updateOpacity)
1572   *     const unsubscribeY = y.on("change", updateOpacity)
1573   *
1574   *     return () => {
1575   *       unsubscribeX()
1576   *       unsubscribeY()
1577   *     }
1578   *   }, [])
1579   *
1580   *   return <motion.div style={{ x }} />
1581   * }
1582   * ```
1583   *
1584   * @param subscriber - A function that receives the latest value.
1585   * @returns A function that, when called, will cancel this subscription.
1586   *
1587   * @deprecated
1588   */
1589  onChange(e) {
1590    return this.on("change", e);
1591  }
1592  on(e, n) {
1593    this.events[e] || (this.events[e] = new An());
1594    const s = this.events[e].add(n);
1595    return e === "change" ? () => {
1596      s(), R.read(() => {
1597        this.events.change.getSize() || this.stop();
1598      });
1599    } : s;
1600  }
1601  clearListeners() {
1602    for (const e in this.events)
1603      this.events[e].clear();
1604  }
1605  /**
1606   * Attaches a passive effect to the `MotionValue`.
1607   */
1608  attach(e, n) {
1609    this.passiveEffect = e, this.stopPassiveEffect = n;
1610  }
1611  /**
1612   * Sets the state of the `MotionValue`.
1613   *
1614   * @remarks
1615   *
1616   * ```jsx
1617   * const x = useMotionValue(0)
1618   * x.set(10)
1619   * ```
1620   *
1621   * @param latest - Latest value to set.
1622   * @param render - Whether to notify render subscribers. Defaults to `true`
1623   *
1624   * @public
1625   */
1626  set(e) {
1627    this.passiveEffect ? this.passiveEffect(e, this.updateAndNotify) : this.updateAndNotify(e);
1628  }
1629  setWithVelocity(e, n, s) {
1630    this.set(n), this.prev = void 0, this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt - s;
1631  }
1632  /**
1633   * Set the state of the `MotionValue`, stopping any active animations,
1634   * effects, and resets velocity to `0`.
1635   */
1636  jump(e, n = !0) {
1637    this.updateAndNotify(e), this.prev = e, this.prevUpdatedAt = this.prevFrameValue = void 0, n && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
1638  }
1639  dirty() {
1640    this.events.change?.notify(this.current);
1641  }
1642  addDependent(e) {
1643    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(e);
1644  }
1645  removeDependent(e) {
1646    this.dependents && this.dependents.delete(e);
1647  }
1648  /**
1649   * Returns the latest state of `MotionValue`
1650   *
1651   * @returns - The latest state of `MotionValue`
1652   *
1653   * @public
1654   */
1655  get() {
1656    return this.current;
1657  }
1658  /**
1659   * @public
1660   */
1661  getPrevious() {
1662    return this.prev;
1663  }
1664  /**
1665   * Returns the latest velocity of `MotionValue`
1666   *
1667   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
1668   *
1669   * @public
1670   */
1671  getVelocity() {
1672    const e = X.now();
1673    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > xs)
1674      return 0;
1675    const n = Math.min(this.updatedAt - this.prevUpdatedAt, xs);
1676    return Ri(parseFloat(this.current) - parseFloat(this.prevFrameValue), n);
1677  }
1678  /**
1679   * Registers a new animation to control this `MotionValue`. Only one
1680   * animation can drive a `MotionValue` at one time.
1681   *
1682   * ```jsx
1683   * value.start()
1684   * ```
1685   *
1686   * @param animation - A function that starts the provided animation
1687   */
1688  start(e) {
1689    return this.stop(), new Promise((n) => {
1690      this.hasAnimated = !0, this.animation = e(n), this.events.animationStart && this.events.animationStart.notify();
1691    }).then(() => {
1692      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
1693    });
1694  }
1695  /**
1696   * Stop the currently active animation.
1697   *
1698   * @public
1699   */
1700  stop() {
1701    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
1702  }
1703  /**
1704   * Returns `true` if this value is currently animating.
1705   *
1706   * @public
1707   */
1708  isAnimating() {
1709    return !!this.animation;
1710  }
1711  clearAnimation() {
1712    delete this.animation;
1713  }
1714  /**
1715   * Destroy and clean up subscribers to this `MotionValue`.
1716   *
1717   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
1718   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
1719   * created a `MotionValue` via the `motionValue` function.
1720   *
1721   * @public
1722   */
1723  destroy() {
1724    this.dependents?.clear(), this.events.destroy?.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
1725  }
1726}
1727function Lt(t, e) {
1728  return new fl(t, e);
1729}
1730const { schedule: _n } = /* @__PURE__ */ Wi(queueMicrotask, !1), it = {
1731  x: !1,
1732  y: !1
1733};
1734function pr() {
1735  return it.x || it.y;
1736}
1737function ml(t) {
1738  return t === "x" || t === "y" ? it[t] ? null : (it[t] = !0, () => {
1739    it[t] = !1;
1740  }) : it.x || it.y ? null : (it.x = it.y = !0, () => {
1741    it.x = it.y = !1;
1742  });
1743}
1744function gr(t, e) {
1745  const n = hl(t), s = new AbortController(), i = {
1746    passive: !0,
1747    ...e,
1748    signal: s.signal
1749  };
1750  return [n, i, () => s.abort()];
1751}
1752function vs(t) {
1753  return !(t.pointerType === "touch" || pr());
1754}
1755function pl(t, e, n = {}) {
1756  const [s, i, o] = gr(t, n), r = (a) => {

2548      x: -o.scroll.offset.x,
2549      y: -o.scroll.offset.y
2550    }), r && (e.x *= r.x.scale, e.y *= r.y.scale, Ir(t, r)), s && bt(o.latestValues) && Et(t, o.latestValues));
2551  }
2552  e.x < Es && e.x > Vs && (e.x = 1), e.y < Es && e.y > Vs && (e.y = 1);
2553}
2554function Vt(t, e) {
2555  t.min = t.min + e, t.max = t.max + e;
2556}
2557function Ds(t, e, n, s, i = 0.5) {
2558  const o = N(t.min, t.max, i);
2559  cn(t, e, n, o, s);
2560}
2561function Et(t, e) {
2562  Ds(t.x, e.x, e.scaleX, e.scale, e.originX), Ds(t.y, e.y, e.scaleY, e.scale, e.originY);
2563}
2564function Fr(t, e) {
2565  return Nr(lc(t.getBoundingClientRect(), e));
2566}
2567function uc(t, e, n) {
2568  const s = Fr(t, n), { scroll: i } = e;
2569  return i && (Vt(s.x, i.offset.x), Vt(s.y, i.offset.y)), s;
2570}
2571const Rs = () => ({
2572  translate: 0,
2573  scale: 1,
2574  origin: 0,
2575  originPoint: 0
2576}), Dt = () => ({
2577  x: Rs(),
2578  y: Rs()
2579}), Ns = () => ({ min: 0, max: 0 }), F = () => ({
2580  x: Ns(),
2581  y: Ns()
2582}), un = { current: null }, Br = { current: !1 };
2583function hc() {
2584  if (Br.current = !0, !!Tn)
2585    if (window.matchMedia) {
2586      const t = window.matchMedia("(prefers-reduced-motion)"), e = () => un.current = t.matches;
2587      t.addEventListener("change", e), e();
2588    } else
2589      un.current = !1;
2590}
2591const dc = /* @__PURE__ */ new WeakMap();
2592function fc(t, e, n) {
2593  for (const s in e) {
2594    const i = e[s], o = n[s];
2595    if (H(i))
2596      t.addValue(s, i);
2597    else if (H(o))
2598      t.addValue(s, Lt(i, { owner: t }));
2599    else if (o !== i)
2600      if (t.hasValue(s)) {
2601        const r = t.getValue(s);
2602        r.liveStyle === !0 ? r.jump(i) : r.hasAnimated || r.set(i);
2603      } else {
2604        const r = t.getStaticValue(s);
2605        t.addValue(s, Lt(r !== void 0 ? r : i, { owner: t }));
2606      }
2607  }
2608  for (const s in n)
2609    e[s] === void 0 && t.removeValue(s);
2610  return e;
2611}
2612const Ls = [
2613  "AnimationStart",
2614  "AnimationComplete",
2615  "Update",
2616  "BeforeLayoutMeasure",
2617  "LayoutMeasure",
2618  "LayoutAnimationStart",
2619  "LayoutAnimationComplete"
2620];
2621class mc {
2622  /**
2623   * This method takes React props and returns found MotionValues. For example, HTML
2624   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
2625   *
2626   * This isn't an abstract method as it needs calling in the constructor, but it is
2627   * intended to be one.
2628   */
2629  scrapeMotionValuesFromProps(e, n, s) {
2630    return {};
2631  }
2632  constructor({ parent: e, props: n, presenceContext: s, reducedMotionConfig: i, blockInitialAnimation: o, visualState: r }, a = {}) {
2633    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = jn, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
2634      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
2635    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
2636      const d = X.now();
2637      this.renderScheduledAt < d && (this.renderScheduledAt = d, R.render(this.render, !1, !0));
2638    };
2639    const { latestValues: l, renderState: u } = r;
2640    this.latestValues = l, this.baseTarget = { ...l }, this.initialValues = n.initial ? { ...l } : {}, this.renderState = u, this.parent = e, this.props = n, this.presenceContext = s, this.depth = e ? e.depth + 1 : 0, this.reducedMotionConfig = i, this.options = a, this.blockInitialAnimation = !!o, this.isControllingVariants = ke(n), this.isVariantNode = Tr(n), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(e && e.current);
2641    const { willChange: c, ...h } = this.scrapeMotionValuesFromProps(n, {}, this);
2642    for (const d in h) {
2643      const m = h[d];
2644      l[d] !== void 0 && H(m) && m.set(l[d]);
2645    }
2646  }
2647  mount(e) {
2648    this.current = e, dc.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.forEac

2648h((n, s) => this.bindToMotionValue(s, n)), Br.current || hc(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : un.current, this.parent?.addChild(this), this.update(this.props, this.presenceContext);
2649  }
2650  unmount() {
2651    this.projection && this.projection.unmount(), pt(this.notifyUpdate), pt(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent?.removeChild(this);
2652    for (const e in this.events)
2653      this.events[e].clear();
2654    for (const e in this.features) {
2655      const n = this.features[e];
2656      n && (n.unmount(), n.isMounted = !1);
2657    }
2658    this.current = null;
2659  }
2660  addChild(e) {
2661    this.children.add(e), this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set()), this.enteringChildren.add(e);
2662  }
2663  removeChild(e) {
2664    this.children.delete(e), this.enteringChildren && this.enteringChildren.delete(e);
2665  }
2666  bindToMotionValue(e, n) {
2667    this.valueSubscriptions.has(e) && this.valueSubscriptions.get(e)();
2668    const s = jt.has(e);
2669    s && this.onBindTransform && this.onBindTransform();
2670    const i = n.on("change", (r) => {
2671      this.latestValues[e] = r, this.props.onUpdate && R.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender();
2672    });
2673    let o;
2674    window.MotionCheckAppearSync && (o = window.MotionCheckAppearSync(this, e, n)), this.valueSubscriptions.set(e, () => {
2675      i(), o && o(), n.owner && n.stop();
2676    });
2677  }
2678  sortNodePosition(e) {
2679    return !this.current || !this.sortInstanceNodePosition || this.type !== e.type ? 0 : this.sortInstanceNodePosition(this.current, e.current);
2680  }
2681  updateFeatures() {
2682    let e = "animation";
2683    for (e in It) {
2684      const n = It[e];
2685      if (!n)
2686        continue;
2687      const { isEnabled: s, Feature: i } = n;
2688      if (!this.features[e] && i && s(this.props) && (this.features[e] = new i(this)), this.features[e]) {
2689        const o = this.features[e];
2690        o.isMounted ? o.update() : (o.mount(), o.isMounted = !0);
2691      }
2692    }
2693  }
2694  triggerBuild() {
2695    this.build(this.renderState, this.latestValues, this.props);
2696  }
2697  /**
2698   * Measure the current viewport box with or without transforms.
2699   * Only measures axis-aligned boxes, rotate and skew must be manually
2700   * removed with a re-render to work.
2701   */
2702  measureViewportBox() {
2703    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : F();
2704  }
2705  getStaticValue(e) {
2706    return this.latestValues[e];
2707  }
2708  setStaticValue(e, n) {
2709    this.latestValues[e] = n;
2710  }
2711  /**
2712   * Update the provided props. Ensure any newly-added motion values are
2713   * added to our map, old ones removed, and listeners updated.
2714   */
2715  update(e, n) {
2716    (e.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = e, this.prevPresenceContext = this.presenceContext, this.presenceContext = n;
2717    for (let s = 0; s < Ls.length; s++) {
2718      const i = Ls[s];
2719      this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
2720      const o = "on" + i, r = e[o];
2721      r && (this.propEventSubscriptions[i] = this.on(i, r));
2722    }
2723    this.prevMotionValues = fc(this, this.scrapeMotionValuesFromProps(e, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
2724  }
2725  getProps() {
2726    return this.props;
2727  }
2728  /**
2729   * Returns the variant definition with a given name.
2730   */
2731  getVariant(e) {
2732    return this.props.variants ? this.props.variants[e] : void 0;
2733  }
2734  /**
2735   * Returns the defined default transition on this component.
2736   */
2737  getDefaultTransition() {
2738    return this.props.transition;
2739  }
2740  getTransformPagePoint() {
2741    return this.props.transformPagePoint;
2742  }
2743  getClosestVariantNode() {
2744    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
2745  }
2746  /**
2747   * Add a child visual element to our set of children.
2748   */
2749  addVariantChild(e) {
2750    const n = this.getClosestVariantNode();
2751    if (n)
2752      return n.variantChildren && n.variantChildren.add(e), () => n.variantChildren.delete(e);
2753  }
2754  /**
2755   * Add a motion value and bind it to this visual element.
2756   */
2757  addValue(e, n) {
2758    const s = this.values.get(e);
2759    n !== s && (s && this.removeValue(e), this.bindToMotionValue(e, n), this.values.set(e, n), this.latestValues[e] = n.get());
2760  }
2761  /**
2762   * Remove a motion value and unbind any active subscriptions.
2763   */
2764  removeValue(e) {
2765    this.values.delete(e);
2766    const n = this.valueSubscriptions.get(e);
2767    n && (n(), this.valueSubscriptions.delete(e)), delete this.latestValues[e], this.removeValueFromRenderState(e, this.renderState);
2768  }
2769  /**
2770   * Check whether we have a motion value for this key
2771   */
2772  hasValue(e) {
2773    return this.values.has(e);
2774  }
2775  getValue(e, n) {
2776    if (this.props.values && this.props.values[e])
2777      return this.props.values[e];
2778    let s = this.values.get(e);
2779    return s === void 0 && n !== void 0 && (s = Lt(n === null ? void 0 : n, { owner: this }), this.addValue(e, s)), s;
2780  }
2781  /**
2782   * If we're trying to animate to a previously unencountered value,
2783   * we need to check for it in our state and as a last resort read it
2784   * directly from the instance (which might have performance implications).
2785   */
2786  readValue(e, n) {
2787    let s = this.latestValues[e] !== void 0 || !this.current ? this.latestValues[e] : this.getBaseTargetFromProps(this.props, e) ?? this.readValueFromInstance(this.current, e, this.options);
2788    return s != null && (typeof s == "string" && (Vi(s) || Di(s)) ? s = parseFloat(s) : !Tl(s) && gt.test(n) && (s = dr(e, n)), this.setBaseTarget(e, H(s) ? s.get() : s