https://axis-fe.up.railway.app/node_modules/.vite/deps/framer-motion.js?v=bf763330

1import __buffer_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_buffer.js?v=bf763330";
2globalThis.Buffer = globalThis.Buffer || __buffer_polyfill;
3import __global_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_global.js?v=bf763330";
4globalThis.global = globalThis.global || __global_polyfill;
5import __process_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_process.js?v=bf763330";
6globalThis.process = globalThis.process || __process_polyfill;
7"use client";
8import {
9  require_jsx_runtime
10} from "/node_modules/.vite/deps/chunk-DIFCGDOZ.js?v=bf763330";
11import {
12  require_react
13} from "/node_modules/.vite/deps/chunk-OLCRR3H2.js?v=bf763330";
14import {
15  __commonJS,
16  __export,
17  __toESM,
18  require_dist,
19  require_dist2,
20  require_dist3
21} from "/node_modules/.vite/deps/chunk-CURNFZRR.js?v=bf763330";
22var require_is_prop_valid_framer_motion = __commonJS({
23  "optional-peer-dep:__vite-optional-peer-dep:@emotion/is-prop-valid:framer-motion"() {
24    var import_dist1069 = __toESM(require_dist());
25    var import_dist1070 = __toESM(require_dist2());
26    var import_dist1071 = __toESM(require_dist3());
27    throw new Error(`Could not resolve "@emotion/is-prop-valid" imported by "framer-motion". Is it installed?`);
28  }
29});
30var import_dist1066 = __toESM(require_dist(), 1);
31var import_dist1067 = __toESM(require_dist2(), 1);
32var import_dist1068 = __toESM(require_dist3(), 1);
33var import_dist31 = __toESM(require_dist(), 1);
34var import_dist32 = __toESM(require_dist2(), 1);
35var import_dist33 = __toESM(require_dist3(), 1);
36var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
37var import_react10 = __toESM(require_react(), 1);
38var import_dist = __toESM(require_dist(), 1);
39var import_dist2 = __toESM(require_dist2(), 1);
40var import_dist3 = __toESM(require_dist3(), 1);
41var import_react = __toESM(require_react(), 1);
42var LayoutGroupContext = (0, import_react.createContext)({});
43var import_dist4 = __toESM(require_dist(), 1);
44var import_dist5 = __toESM(require_dist2(), 1);
45var import_dist6 = __toESM(require_dist3(), 1);
46var import_react2 = __toESM(require_react(), 1);
47function useConstant(init) {
48  const ref = (0, import_react2.useRef)(null);
49  if (ref.current === null) {
50    ref.current = init();
51  }
52  return ref.current;
53}
54var import_dist16 = __toESM(require_dist(), 1);
55var import_dist17 = __toESM(require_dist2(), 1);
56var import_dist18 = __toESM(require_dist3(), 1);
57var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
58var React2 = __toESM(require_react(), 1);
59var import_react6 = __toESM(require_react(), 1);
60var import_dist7 = __toESM(require_dist(), 1);
61var import_dist8 = __toESM(require_dist2(), 1);
62var import_dist9 = __toESM(require_dist3(), 1);
63var import_react3 = __toESM(require_react(), 1);
64var PresenceContext = (0, import_react3.createContext)(null);
65var import_dist13 = __toESM(require_dist(), 1);
66var import_dist14 = __toESM(require_dist2(), 1);
67var import_dist15 = __toESM(require_dist3(), 1);
68var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
69var React = __toESM(require_react(), 1);
70var import_react5 = __toESM(require_react(), 1);
71var import_dist10 = __toESM(require_dist(), 1);
72var import_dist11 = __toESM(require_dist2(), 1);
73var import_dist12 = __toESM(require_dist3(), 1);
74var import_react4 = __toESM(require_react(), 1);
75var MotionConfigContext = (0, import_react4.createContext)({
76  transformPagePoint: (p) => p,
77  isStatic: false,
78  reducedMotion: "never"
79});
80var PopChildMeasure = class extends React.Component {
81  getSnapshotBeforeUpdate(prevProps) {
82    const element = this.props.childRef.current;
83    if (element && prevProps.isPresent && !this.props.isPresent) {
84      const size = this.props.sizeRef.current;
85      size.height = element.offsetHeight || 0;
86      size.width = element.offsetWidth || 0;
87      size.top = element.offsetTop;
88      size.left = element.offsetLeft;
89    }
90    return null;
91  }
92  /**
93   * Required with getSnapshotBeforeUpdate to stop React complaining.
94   */
95  componentDidUpdate() {
96  }
97  render() {
98    return this.props.children;
99  }
100};
101function PopChild({ children, isPresent: isPresent2 }) {
102  const id4 = (0, import_react5.useId)();
103  const ref = (0, import_react5.useRef)(null);
104  const size = (0, import_react5.useRef)({
105    width: 0,
106    height: 0,
107    top: 0,
108    left: 0
109  });
110  const { nonce } = (0, import_react5.useContext)(MotionConfigContext);
111  (0, import_react5.useInsertionEffect)(() => {
112    const { width, height, top, left } = size.current;
113    if (isPresent2 || !ref.current || !width || !height)
114      return;
115    ref.current.dataset.motionPopId = id4;
116    const style = document.createElement("style");
117    if (nonce)
118      style.nonce = nonce;
119    document.head.appendChild(style);
120    if (style.sheet) {
121      style.sheet.insertRule(`
122          [data-motion-pop-id="${id4}"] {
123            position: absolute !important;
124            width: ${width}px !important;
125            height: ${height}px !important;
126            top: ${top}px !important;
127            left: ${left}px !important;
128          }
129        `);
130    }
131    return () => {
132      document.head.removeChild(style);
133    };
134  }, [isPresent2]);
135  return (0, import_jsx_runtime.jsx)(PopChildMeasure, { isPresent: isPresent2, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref }) });
136}
137var PresenceChild = ({ children, initial, isPresent: isPresent2, onExitComplete, custom, presenceAffectsLayout, mode }) => {
138  const presenceChildren = useConstant(newChildrenMap);
139  const id4 = (0, import_react6.useId)();
140  const memoizedOnExitComplete = (0, import_react6.useCallback)((childId) => {
141    presenceChildren.set(childId, true);
142    for (const isComplete of presenceChildren.values()) {
143      if (!isComplete)
144        return;
145    }
146    onExitComplete && onExitComplete();
147  }, [presenceChildren, onExitComplete]);
148  const context = (0, import_react6.useMemo)(
149    () => ({
150      id: id4,
151      initial,
152      isPresent: isPresent2,
153      custom,
154      onExitComplete: memoizedOnExitComplete,
155      register: (childId) => {
156        presenceChildren.set(childId, false);
157        return () => presenceChildren.delete(childId);
158      }
159    }),
160    /**
161     * If the presence of a child affects the layout of the components around it,
162     * we want to make a new context value to ensure they get re-rendered
163     * so they can detect that layout change.
164     */
165    presenceAffectsLayout ? [Math.random(), memoizedOnExitComplete] : [isPresent2, memoizedOnExitComplete]
166  );
167  (0, import_react6.useMemo)(() => {

168    presenceChildren.forEach((_, key) => presenceChildren.set(key, false));
169  }, [isPresent2]);
170  React2.useEffect(() => {
171    !isPresent2 && !presenceChildren.size && onExitComplete && onExitComplete();
172  }, [isPresent2]);
173  if (mode === "popLayout") {
174    children = (0, import_jsx_runtime2.jsx)(PopChild, { isPresent: isPresent2, children });
175  }
176  return (0, import_jsx_runtime2.jsx)(PresenceContext.Provider, { value: context, children });
177};
178function newChildrenMap() {
179  return /* @__PURE__ */ new Map();
180}
181var import_dist19 = __toESM(require_dist(), 1);
182var import_dist20 = __toESM(require_dist2(), 1);
183var import_dist21 = __toESM(require_dist3(), 1);
184var import_react7 = __toESM(require_react(), 1);
185function usePresence(subscribe = true) {
186  const context = (0, import_react7.useContext)(PresenceContext);
187  if (context === null)
188    return [true, null];
189  const { isPresent: isPresent2, onExitComplete, register } = context;
190  const id4 = (0, import_react7.useId)();
191  (0, import_react7.useEffect)(() => {
192    if (subscribe)
193      register(id4);
194  }, [subscribe]);
195  const safeToRemove = (0, import_react7.useCallback)(() => subscribe && onExitComplete && onExitComplete(id4), [id4, onExitComplete, subscribe]);
196  return !isPresent2 && onExitComplete ? [false, safeToRemove] : [true];
197}
198function useIsPresent() {
199  return isPresent((0, import_react7.useContext)(PresenceContext));
200}
201function isPresent(context) {

202  return context === null ? true : context.isPresent;
203}
204var import_dist22 = __toESM(require_dist(), 1);
205var import_dist23 = __toESM(require_dist2(), 1);
206var import_dist24 = __toESM(require_dist3(), 1);
207var import_react8 = __toESM(require_react(), 1);
208var getChildKey = (child) => child.key || "";
209function onlyElements(children) {
210  const filtered = [];
211  import_react8.Children.forEach(children, (child) => {
212    if ((0, import_react8.isValidElement)(child))
213      filtered.push(child);
214  });
215  return filtered;
216}
217var import_dist28 = __toESM(require_dist(), 1);
218var import_dist29 = __toESM(require_dist2(), 1);
219var import_dist30 = __toESM(require_dist3(), 1);
220var import_react9 = __toESM(require_react(), 1);
221var import_dist25 = __toESM(require_dist(), 1);
222var import_dist26 = __toESM(require_dist2(), 1);
223var import_dist27 = __toESM(require_dist3(), 1);
224var isBrowser = typeof window !== "undefined";
225var useIsomorphicLayoutEffect = isBrowser ? import_react9.useLayoutEffect : import_react9.useEffect;
226var AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = "sync", propagate = false }) => {
227  const [isParentPresent, safeToRemove] = usePresence(propagate);
228  const presentChildren = (0, import_react10.useMemo)(() => onlyElements(children), [children]);
229  const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);
230  const isInitialRender = (0, import_react10.useRef)(true);
231  const pendingPresentChildren = (0, import_react10.useRef)(presentChildren);
232  const exitComplete = useConstant(() => /* @__PURE__ */ new Map());
233  const [diffedChildren, setDiffedChildren] = (0, import_react10.useState)(presentChildren);
234  const [renderedChildren, setRenderedChildren] = (0, import_react10.useState)(presentChildren);
235  useIsomorphicLayoutEffect(() => {
236    isInitialRender.current = false;
237    pendingPresentChildren.current = presentChildren;
238    for (let i = 0; i < renderedChildren.length; i++) {
239      const key = getChildKey(renderedChildren[i]);
240      if (!presentKeys.includes(key)) {
241        if (exitComplete.get(key) !== true) {
242          exitComplete.set(key, false);
243        }
244      } else {
245        exitComplete.delete(key);
246      }
247    }
248  }, [renderedChildren, presentKeys.length, presentKeys.join("-")]);
249  const exitingChildren = [];
250  if (presentChildren !== diffedChildren) {
251    let nextChildren = [...presentChildren];
252    for (let i = 0; i < renderedChildren.length; i++) {
253      const child = renderedChildren[i];
254      const key = getChildKey(child);
255      if (!presentKeys.includes(key)) {
256        nextChildren.splice(i, 0, child);
257        exitingChildren.push(child);
258      }
259    }
260    if (mode === "wait" && exitingChildren.length) {
261      nextChildren = exitingChildren;
262    }
263    setRenderedChildren(onlyElements(nextChildren));
264    setDiffedChildren(presentChildren);
265    return;
266  }
267  if (mode === "wait" && renderedChildren.length > 1) {
268    console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
269  }
270  const { forceRender } = (0, import_react10.useContext)(LayoutGroupContext);
271  return (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: renderedChildren.map((child) => {
272    const key = getChildKey(child);
273    const isPresent2 = propagate && !isParentPresent ? false : presentChildren === renderedChildren || presentKeys.includes(key);
274    const onExit = () => {
275      if (exitComplete.has(key)) {
276        exitComplete.set(key, true);
277      } else {
278        return;
279      }
280      let isEveryExitComplete = true;
281      exitComplete.forEach((isExitComplete) => {
282        if (!isExitComplete)
283          isEveryExitComplete = false;
284      });
285      if (isEveryExitComplete) {
286        forceRender === null || forceRender === void 0 ? void 0 : forceRender();
287        setRenderedChildren(pendingPresentChildren.current);
288        propagate && (safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove());
289        onExitComplete && onExitComplete();
290      }
291    };
292    return (0, import_jsx_runtime3.jsx)(PresenceChild, { isPresent: isPresent2, initial: !isInitialRender.current || initial ? void 0 : false, custom: isPresent2 ? void 0 : custom, presenceAffectsLayout, mode, onExitComplete: isPresent2 ? void 0 : onExit, children: child }, key);
293  }) });
294};
295var import_dist76 = __toESM(require_dist(), 1);
296var import_dist77 = __toESM(require_dist2(), 1);
297var import_dist78 = __toESM(require_dist3(), 1);
298var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
299var import_react14 = __toESM(require_react(), 1);
300var import_dist34 = __toESM(require_dist(), 1);
301var import_dist35 = __toESM(require_dist2(), 1);
302var import_dist36 = __toESM(require_dist3(), 1);
303var import_react11 = __toESM(require_react(), 1);
304var DeprecatedLayoutGroupContext = (0, import_react11.createContext)(null);
305var import_dist70 = __toESM(require_dist(), 1);
306var import_dist71 = __toESM(require_dist2(), 1);
307var import_dist72 = __toESM(require_dist3(), 1);
308var import_react13 = __toESM(require_react(), 1);
309var import_dist37 = __toESM(require_dist(), 1);
310var import_dist38 = __toESM(require_dist2(), 1);
311var import_dist39 = __toESM(require_dist3(), 1);
312var import_react12 = __toESM(require_react(), 1);
313function useIsMounted() {
314  const isMounted = (0, import_react12.useRef)(false);
315  useIsomorphicLayoutEffect(() => {
316    isMounted.current = true;
317    return () => {
318      isMounted.current = false;

319    };
320  }, []);
321  return isMounted;
322}
323var import_dist67 = __toESM(require_dist(), 1);
324var import_dist68 = __toESM(require_dist2(), 1);
325var import_dist69 = __toESM(require_dist3(), 1);
326var import_dist55 = __toESM(require_dist(), 1);
327var import_dist56 = __toESM(require_dist2(), 1);
328var import_dist57 = __toESM(require_dist3(), 1);
329var import_dist43 = __toESM(require_dist(), 1);
330var import_dist44 = __toESM(require_dist2(), 1);
331var import_dist45 = __toESM(require_dist3(), 1);
332var import_dist40 = __toESM(require_dist(), 1);
333var import_dist41 = __toESM(require_dist2(), 1);
334var import_dist42 = __toESM(require_dist3(), 1);
335var noop = (any) => any;
336var warning = noop;
337var invariant = noop;
338if (true) {
339  warning = (check, message) => {
340    if (!check && typeof console !== "undefined") {
341      console.warn(message);
342    }
343  };
344  invariant = (check, message) => {
345    if (!check) {
346      throw new Error(message);
347    }
348  };
349}
350var import_dist46 = __toESM(require_dist(), 1);
351var import_dist47 = __toESM(require_dist2(), 1);
352var import_dist48 = __toESM(require_dist3(), 1);
353function memo(callback) {
354  let result;
355  return () => {
356    if (result === void 0)
357      result = callback();
358    return result;
359  };
360}
361var import_dist49 = __toESM(require_dist(), 1);
362var import_dist50 = __toESM(require_dist2(), 1);
363var import_dist51 = __toESM(require_dist3(), 1);
364var progress = (from, to, value) => {
365  const toFromDifference = to - from;
366  return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;
367};
368var import_dist52 = __toESM(require_dist(), 1);
369var import_dist53 = __toESM(require_dist2(), 1);
370var import_dist54 = __toESM(require_dist3(), 1);
371var secondsToMilliseconds = (seconds) => seconds * 1e3;
372var millisecondsToSeconds = (milliseconds) => milliseconds / 1e3;
373var import_dist64 = __toESM(require_dist(), 1);
374var import_dist65 = __toESM(require_dist2(), 1);
375var import_dist66 = __toESM(require_dist3(), 1);
376var import_dist58 = __toESM(require_dist(), 1);
377var import_dist59 = __toESM(require_dist2(), 1);
378var import_dist60 = __toESM(require_dist3(), 1);
379var MotionGlobalConfig = {
380  skipAnimations: false,
381  useManualTiming: false
382};
383var import_dist61 = __toESM(require_dist(), 1);
384var import_dist62 = __toESM(require_dist2(), 1);
385var import_dist63 = __toESM(require_dist3(), 1);
386function createRenderStep(runNextFrame) {
387  let thisFrame = /* @__PURE__ */ new Set();
388  let nextFrame = /* @__PURE__ */ new Set();
389  let isProcessing = false;
390  let flushNextFrame = false;
391  const toKeepAlive = /* @__PURE__ */ new WeakSet();
392  let latestFrameData = {
393    delta: 0,
394    timestamp: 0,
395    isProcessing: false
396  };
397  function triggerCallback(callback) {
398    if (toKeepAlive.has(callback)) {
399      step.schedule(callback);
400      runNextFrame();
401    }
402    callback(latestFrameData);
403  }
404  const step = {
405    /**
406     * Schedule a process to run on the next frame.
407     */
408    schedule: (callback, keepAlive = false, immediate = false) => {
409      const addToCurrentFrame = immediate && isProcessing;
410      const queue = addToCurrentFrame ? thisFrame : nextFrame;
411      if (keepAlive)
412        toKeepAlive.add(callback);
413      if (!queue.has(callback))
414        queue.add(callback);
415      return callback;
416    },
417    /**
418     * Cancel the provided callback from running on the next frame.
419     */
420    cancel: (callback) => {
421      nextFrame.delete(callback);
422      toKeepAlive.delete(callback);
423    },
424    /**
425     * Execute all schedule callbacks.
426     */
427    process: (frameData2) => {
428      latestFrameData = frameData2;
429      if (isProcessing) {
430        flushNextFrame = true;
431        return;
432      }
433      isProcessing = true;
434      [thisFrame, nextFrame] = [nextFrame, thisFrame];
435      thisFrame.forEach(triggerCallback);
436      thisFrame.clear();
437      isProcessing = false;
438      if (flushNextFrame) {
439        flushNextFrame = false;
440        step.process(frameData2);
441      }
442    }
443  };
444  return step;
445}
446var stepsOrder = [
447  "read",
448  // Read
449  "resolveKeyframes",
450  // Write/Read/Write/Read
451  "update",
452  // Compute
453  "preRender",
454  // Compute
455  "render",
456  // Write
457  "postRender"
458  // Compute
459];
460var maxElapsed = 40;
461function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
462  let runNextFrame = false;

463  let useDefaultElapsed = true;
464  const state2 = {
465    delta: 0,
466    timestamp: 0,
467    isProcessing: false
468  };
469  const flagRunNextFrame = () => runNextFrame = true;
470  const steps2 = stepsOrder.reduce((acc, key) => {
471    acc[key] = createRenderStep(flagRunNextFrame);
472    return acc;
473  }, {});
474  const { read, resolveKeyframes, update, preRender, render, postRender } = steps2;
475  const processBatch = () => {
476    const timestamp = MotionGlobalConfig.useManualTiming ? state2.timestamp : performance.now();
477    runNextFrame = false;
478    state2.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state2.timestamp, maxElapsed), 1);
479    state2.timestamp = timestamp;
480    state2.isProcessing = true;
481    read.process(state2);
482    resolveKeyframes.process(state2);
483    update.process(state2);
484    preRender.process(state2);
485    render.process(state2);
486    postRender.process(state2);
487    state2.isProcessing = false;
488    if (runNextFrame && allowKeepAlive) {
489      useDefaultElapsed = false;
490      scheduleNextBatch(processBatch);
491    }
492  };
493  const wake = () => {
494    runNextFrame = true;
495    useDefaultElapsed = true;
496    if (!state2.isProcessing) {
497      scheduleNextBatch(processBatch);
498    }
499  };
500  const schedule = stepsOrder.reduce((acc, key) => {
501    const step = steps2[key];
502    acc[key] = (process2, keepAlive = false, immediate = false) => {
503      if (!runNextFrame)
504        wake();
505      return step.schedule(process2, keepAlive, immediate);
506    };
507    return acc;
508  }, {});
509  const cancel = (process2) => {
510    for (let i = 0; i < stepsOrder.length; i++) {
511      steps2[stepsOrder[i]].cancel(process2);
512    }
513  };
514  return { schedule, cancel, state: state2, steps: steps2 };
515}
516var { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
517function useForceUpdate() {
518  const isMounted = useIsMounted();
519  const [forcedRenderCount, setForcedRenderCount] = (0, import_react13.useState)(0);
520  const forceRender = (0, import_react13.useCallback)(() => {
521    isMounted.current && setForcedRenderCount(forcedRenderCount + 1);
522  }, [forcedRenderCount]);
523  const deferredForceRender = (0, import_react13.useCallback)(() => frame.postRender(forceRender), [forceRender]);
524  return [deferredForceRender, forcedRenderCount];
525}
526var import_dist73 = __toESM(require_dist(), 1);
527var import_dist74 = __toESM(require_dist2(), 1);
528var import_dist75 = __toESM(require_dist3(), 1);
529var notify = (node) => !node.isLayoutDirty && node.willUpdate(false);
530function nodeGroup() {
531  const nodes = /* @__PURE__ */ new Set();
532  const subscriptions = /* @__PURE__ */ new WeakMap();
533  const dirtyAll = () => nodes.forEach(notify);
534  return {
535    add: (node) => {
536      nodes.add(node);
537      subscriptions.set(node, node.addEventListener("willUpdate", dirtyAll));
538    },
539    remove: (node) => {
540      nodes.delete(node);
541      const unsubscribe = subscriptions.get(node);
542      if (unsubscribe) {
543        unsubscribe();
544        subscriptions.delete(node);
545      }
546      dirtyAll();
547    },
548    dirty: dirtyAll
549  };
550}
551var shouldInheritGroup = (inherit) => inherit === true;
552var shouldInheritId = (inherit) => shouldInheritGroup(inherit === true) || inherit === "id";
553var LayoutGroup = ({ children, id: id4, inherit = true }) => {
554  const layoutGroupContext = (0, import_react14.useContext)(LayoutGroupContext);
555  const deprecatedLayoutGroupContext = (0, import_react14.useContext)(DeprecatedLayoutGroupContext);
556  const [forceRender, key] = useForceUpdate();
557  const context = (0, import_react14.useRef)(null);
558  const upstreamId = layoutGroupContext.id || deprecatedLayoutGroupContext;
559  if (context.current === null) {
560    if (shouldInheritId(inherit) && upstreamId) {
561      id4 = id4 ? upstreamId + "-" + id4 : upstreamId;
562    }
563    context.current = {
564      id: id4,
565      group: shouldInheritGroup(inherit) ? layoutGroupContext.group || nodeGroup() : nodeGroup()
566    };
567  }
568  const memoizedContext = (0, import_react14.useMemo)(() => ({ ...context.current, forceRender }), [key]);
569  return (0, import_jsx_runtime4.jsx)(LayoutGroupContext.Provider, { value: memoizedContext, children });
570};
571var import_dist88 = __toESM(require_dist(), 1);
572var import_dist89 = __toESM(require_dist2(), 1);
573var import_dist90 = __toESM(require_dist3(), 1);
574var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
575var import_react16 = __toESM(require_react(), 1);
576var import_dist79 = __toESM(require_dist(), 1);
577var import_dist80 = __toESM(require_dist2(), 1);
578var import_dist81 = __toESM(require_dist3(), 1);
579var import_react15 = __toESM(require_react(), 1);
580var LazyContext = (0, import_react15.createContext)({ strict: false });
581var import_dist85 = __toESM(require_dist(), 1);
582var import_dist86 = __toESM(require_dist2(), 1);
583var import_dist87 = __toESM(require_dist3(), 1);
584var import_dist82 = __toESM(require_dist(), 1);
585var import_dist83 = __toESM(require_dist2(), 1);
586var import_dist84 = __toESM(require_dist3(), 1);
587var featureProps = {
588  animation: [
589    "animate",
590    "variants",
591    "whileHover",
592    "whileTap",
593    "exit",
594    "whileInView",
595    "whileFocus",
596    "whileDrag"
597  ],
598  exit: ["exit"],
599  drag: ["drag", "dragControls"],
600  focus: ["whileFocus"],
601  hover: ["whileHover", "onHoverStart", "onHoverEnd"],

602  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
603  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
604  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
605  layout: ["layout", "layoutId"]
606};
607var featureDefinitions = {};
608for (const key in featureProps) {
609  featureDefinitions[key] = {
610    isEnabled: (props) => featureProps[key].some((name) => !!props[name])
611  };
612}
613function loadFeatures(features) {
614  for (const key in features) {
615    featureDefinitions[key] = {
616      ...featureDefinitions[key],
617      ...features[key]
618    };
619  }
620}
621function LazyMotion({ children, features, strict = false }) {
622  const [, setIsLoaded] = (0, import_react16.useState)(!isLazyBundle(features));
623  const loadedRenderer = (0, import_react16.useRef)(void 0);
624  if (!isLazyBundle(features)) {
625    const { renderer, ...loadedFeatures } = features;
626    loadedRenderer.current = renderer;
627    loadFeatures(loadedFeatures);
628  }
629  (0, import_react16.useEffect)(() => {
630    if (isLazyBundle(features)) {
631      features().then(({ renderer, ...loadedFeatures }) => {
632        loadFeatures(loadedFeatures);
633        loadedRenderer.current = renderer;
634        setIsLoaded(true);
635      });
636    }
637  }, []);
638  return (0, import_jsx_runtime5.jsx)(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict }, children });
639}
640function isLazyBundle(features) {
641  return typeof features === "function";
642}
643var import_dist97 = __toESM(require_dist(), 1);
644var import_dist98 = __toESM(require_dist2(), 1);
645var import_dist99 = __toESM(require_dist3(), 1);
646var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
647var import_react17 = __toESM(require_react(), 1);
648var import_dist94 = __toESM(require_dist(), 1);
649var import_dist95 = __toESM(require_dist2(), 1);
650var import_dist96 = __toESM(require_dist3(), 1);
651var import_dist91 = __toESM(require_dist(), 1);
652var import_dist92 = __toESM(require_dist2(), 1);
653var import_dist93 = __toESM(require_dist3(), 1);
654var validMotionProps = /* @__PURE__ */ new Set([
655  "animate",
656  "exit",
657  "variants",
658  "initial",
659  "style",
660  "values",
661  "variants",
662  "transition",
663  "transformTemplate",
664  "custom",
665  "inherit",
666  "onBeforeLayoutMeasure",
667  "onAnimationStart",
668  "onAnimationComplete",
669  "onUpdate",
670  "onDragStart",
671  "onDrag",
672  "onDragEnd",
673  "onMeasureDragConstraints",
674  "onDirectionLock",
675  "onDragTransitionEnd",
676  "_dragX",
677  "_dragY",
678  "onHoverStart",
679  "onHoverEnd",
680  "onViewportEnter",
681  "onViewportLeave",
682  "globalTapTarget",
683  "ignoreStrict",
684  "viewport"
685]);
686function isValidMotionProp(key) {
687  return key.startsWith("while") || key.startsWith("drag") && key !== "draggable" || key.startsWith("layout") || key.startsWith("onTap") || key.startsWith("onPan") || key.startsWith("onLayout") || validMotionProps.has(key);
688}
689var shouldForward = (key) => !isValidMotionProp(key);
690function loadExternalIsValidProp(isValidProp) {
691  if (!isValidProp)
692    return;
693  shouldForward = (key) => key.startsWith("on") ? !isValidMotionProp(key) : isValidProp(key);
694}
695try {
696  loadExternalIsValidProp(require_is_prop_valid_framer_motion().default);
697} catch (_a) {
698}
699function filterProps(props, isDom, forwardMotionProps) {
700  const filteredProps = {};
701  for (const key in props) {
702    if (key === "values" && typeof props.values === "object")
703      continue;
704    if (shouldForward(key) || forwardMotionProps === true && isValidMotionProp(key) || !isDom && !isValidMotionProp(key) || // If trying to use native HTML drag events, forward drag listeners
705    props["draggable"] && key.startsWith("onDrag")) {
706      filteredProps[key] = props[key];
707    }
708  }
709  return filteredProps;
710}
711function MotionConfig({ children, isValidProp, ...config }) {
712  isValidProp && loadExternalIsValidProp(isValidProp);
713  config = { ...(0, import_react17.useContext)(MotionConfigContext), ...config };
714  config.isStatic = useConstant(() => config.isStatic);
715  const context = (0, import_react17.useMemo)(() => config, [
716    JSON.stringify(config.transition),
717    config.transformPagePoint,
718    config.reducedMotion
719  ]);
720  return (0, import_jsx_runtime6.jsx)(MotionConfigContext.Provider, { value: context, children });
721}
722var import_dist274 = __toESM(require_dist(), 1);
723var import_dist275 = __toESM(require_dist2(), 1);
724var import_dist276 = __toESM(require_dist3(), 1);
725var import_dist103 = __toESM(require_dist(), 1);
726var import_dist104 = __toESM(require_dist2(), 1);
727var import_dist105 = __toESM(require_dist3(), 1);
728var import_dist100 = __toESM(require_dist(), 1);
729var import_dist101 = __toESM(require_dist2(), 1);
730var import_dist102 = __toESM(require_dist3(), 1);
731var warned = /* @__PURE__ */ new Set();
732function warnOnce(condition, message, element) {
733  if (condition || warned.has(message))
734    return;
735  console.warn(message);
736  if (element)
737    console.warn(element);
738  warned.add(message);
739}
740function createDOMMotionComponentProxy(componentFactory) {
741  if (typeof Proxy === "undefined") {
742    return componentFactory;
743  }
744  const componentCache = /* @__PURE__ */ new Map();
745  const deprecatedFactoryFunction = (...args) => {
746    if (true) {
747      warnOnce(false, "motion() is deprecated. Use motion.create() instead.");
748    }
749    return componentFactory(...args);
750  };
751  return new Proxy(deprecatedFactoryFunction, {
752    /**
753     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.

754     * The prop name is passed through as `key` and we can use that to generate a `motion`
755     * DOM component with that name.
756     */
757    get: (_target, key) => {
758      if (key === "create")
759        return componentFactory;
760      if (!componentCache.has(key)) {
761        componentCache.set(key, componentFactory(key));
762      }
763      return componentCache.get(key);
764    }
765  });
766}
767var import_dist271 = __toESM(require_dist(), 1);
768var import_dist272 = __toESM(require_dist2(), 1);
769var import_dist273 = __toESM(require_dist3(), 1);
770var import_dist268 = __toESM(require_dist(), 1);
771var import_dist269 = __toESM(require_dist2(), 1);
772var import_dist270 = __toESM(require_dist3(), 1);
773var import_dist151 = __toESM(require_dist(), 1);
774var import_dist152 = __toESM(require_dist2(), 1);
775var import_dist153 = __toESM(require_dist3(), 1);
776var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
777var import_react23 = __toESM(require_react(), 1);
778var import_dist106 = __toESM(require_dist(), 1);
779var import_dist107 = __toESM(require_dist2(), 1);
780var import_dist108 = __toESM(require_dist3(), 1);
781var import_react18 = __toESM(require_react(), 1);
782var MotionContext = (0, import_react18.createContext)({});
783var import_dist124 = __toESM(require_dist(), 1);
784var import_dist125 = __toESM(require_dist2(), 1);
785var import_dist126 = __toESM(require_dist3(), 1);
786var import_react19 = __toESM(require_react(), 1);
787var import_dist121 = __toESM(require_dist(), 1);
788var import_dist122 = __toESM(require_dist2(), 1);
789var import_dist123 = __toESM(require_dist3(), 1);
790var import_dist109 = __toESM(require_dist(), 1);
791var import_dist110 = __toESM(require_dist2(), 1);
792var import_dist111 = __toESM(require_dist3(), 1);
793function isVariantLabel(v) {
794  return typeof v === "string" || Array.isArray(v);
795}
796var import_dist118 = __toESM(require_dist(), 1);
797var import_dist119 = __toESM(require_dist2(), 1);
798var import_dist120 = __toESM(require_dist3(), 1);
799var import_dist112 = __toESM(require_dist(), 1);
800var import_dist113 = __toESM(require_dist2(), 1);
801var import_dist114 = __toESM(require_dist3(), 1);
802function isAnimationControls(v) {
803  return v !== null && typeof v === "object" && typeof v.start === "function";
804}
805var import_dist115 = __toESM(require_dist(), 1);
806var import_dist116 = __toESM(require_dist2(), 1);
807var import_dist117 = __toESM(require_dist3(), 1);
808var variantPriorityOrder = [
809  "animate",
810  "whileInView",
811  "whileFocus",
812  "whileHover",
813  "whileTap",
814  "whileDrag",
815  "exit"
816];
817var variantProps = ["initial", ...variantPriorityOrder];
818function isControllingVariants(props) {
819  return isAnimationControls(props.animate) || variantProps.some((name) => isVariantLabel(props[name]));
820}
821function isVariantNode(props) {
822  return Boolean(isControllingVariants(props) || props.variants);
823}
824function getCurrentTreeVariants(props, context) {
825  if (isControllingVariants(props)) {
826    const { initial, animate: animate2 } = props;
827    return {
828      initial: initial === false || isVariantLabel(initial) ? initial : void 0,
829      animate: isVariantLabel(animate2) ? animate2 : void 0
830    };
831  }
832  return props.inherit !== false ? context : {};
833}
834function useCreateMotionContext(props) {
835  const { initial, animate: animate2 } = getCurrentTreeVariants(props, (0, import_react19.useContext)(MotionContext));
836  return (0, import_react19.useMemo)(() => ({ initial, animate: animate2 }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate2)]);
837}
838function variantLabelsAsDependency(prop) {
839  return Array.isArray(prop) ? prop.join(" ") : prop;
840}
841var import_dist127 = __toESM(require_dist(), 1);
842var import_dist128 = __toESM(require_dist2(), 1);
843var import_dist129 = __toESM(require_dist3(), 1);
844var motionComponentSymbol = Symbol.for("motionComponentSymbol");
845var import_dist133 = __toESM(require_dist(), 1);
846var import_dist134 = __toESM(require_dist2(), 1);
847var import_dist135 = __toESM(require_dist3(), 1);
848var import_react20 = __toESM(require_react(), 1);
849var import_dist130 = __toESM(require_dist(), 1);
850var import_dist131 = __toESM(require_dist2(), 1);
851var import_dist132 = __toESM(require_dist3(), 1);
852function isRefObject(ref) {
853  return ref && typeof ref === "object" && Object.prototype.hasOwnProperty.call(ref, "current");
854}
855function useMotionRef(visualState, visualElement, externalRef) {
856  return (0, import_react20.useCallback)(
857    (instance) => {
858      if (instance) {
859        visualState.onMount && visualState.onMount(instance);
860      }
861      if (visualElement) {
862        if (instance) {
863          visualElement.mount(instance);
864        } else {
865          visualElement.unmount();
866        }
867      }
868      if (externalRef) {
869        if (typeof externalRef === "function") {
870          externalRef(instance);
871        } else if (isRefObject(externalRef)) {
872          externalRef.current = instance;
873        }
874      }
875    },
876    /**
877     * Only pass a new ref callback to React if we've received a visual element
878     * factory. Otherwise we'll be mounting/remounting every time externalRef
879     * or other dependencies change.
880     */
881    [visualElement]
882  );
883}
884var import_dist148 = __toESM(require_dist(), 1);
885var import_dist149 = __toESM(require_dist2(), 1);
886var import_dist150 = __toESM(require_dist3(), 1);
887var import_react22 = __toESM(require_react(), 1);
888var import_dist139 = __toESM(require_dist(), 1);
889var import_dist140 = __toESM(require_dist2(), 1);
890var import_dist141 = __toESM(require_dist3(), 1);
891var import_dist136 = __toESM(require_dist(), 1);
892var import_dist137 = __toESM(require_dist2(), 1);
893var import_dist138 = __toESM(require_dist3(), 1);
894var camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase();
895var optimizedAppearDataId = "framerAppearId";
896var optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);
897var import_dist142 = __toESM(require_dist(), 1);
898var import_dist143 = __toESM(require_dist2(), 1);
899var import_dist144 = __toESM(require_dist3(), 1);
900var { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);
901var import_dist145 = __toESM(require_dist(), 1);
902var import_dist146 = __toESM(require_dist2(), 1);
903var import_dist147 = __toESM(require_dist3(), 1);
904var import_react21 = __toESM(require_react(), 1);
905var SwitchLayoutGroupContext = (0, import_react21.createContext)({});
906function useVisualElement(Component3, visualState, props, createVisualElement, ProjectionNodeConstructor) {
907  var _a, _b;
908  const { visualElement: parent } = (0, import_react22.useContext)(MotionContext);
909  const lazyContext = (0, import_react22.useContext)(LazyContext);
910  const presenceContext = (0, import_react22.useContext)(PresenceContext);
911  const reducedMotionConfig = (0, import_react22.useContext)(MotionConfigContext).reducedMotion;
912  const visualElementRef = (0, import_react22.useRef)(null);
913  createVisualElement = createVisualElement || lazyContext.renderer;
914  if (!visualElementRef.current && createVisualElement) {
915    visualElementRef.current = createVisualElement(Component3, {
916      visualState,
917      parent,
918      props,
919      presenceContext,

920      blockInitialAnimation: presenceContext ? presenceContext.initial === false : false,
921      reducedMotionConfig
922    });
923  }
924  const visualElement = visualElementRef.current;
925  const initialLayoutGroupConfig = (0, import_react22.useContext)(SwitchLayoutGroupContext);
926  if (visualElement && !visualElement.projection && ProjectionNodeConstructor && (visualElement.type === "html" || visualElement.type === "svg")) {
927    createProjectionNode(visualElementRef.current, props, ProjectionNodeConstructor, initialLayoutGroupConfig);
928  }
929  const isMounted = (0, import_react22.useRef)(false);
930  (0, import_react22.useInsertionEffect)(() => {
931    if (visualElement && isMounted.current) {
932      visualElement.update(props, presenceContext);
933    }
934  });
935  const optimisedAppearId = props[optimizedAppearDataAttribute];
936  const wantsHandoff = (0, import_react22.useRef)(Boolean(optimisedAppearId) && !((_a = window.MotionHandoffIsComplete) === null || _a === void 0 ? void 0 : _a.call(window, optimisedAppearId)) && ((_b = window.MotionHasOptimisedAnimation) === null || _b === void 0 ? void 0 : _b.call(window, optimisedAppearId)));
937  useIsomorphicLayoutEffect(() => {
938    if (!visualElement)
939      return;
940    isMounted.current = true;
941    window.MotionIsMounted = true;
942    visualElement.updateFeatures();
943    microtask.render(visualElement.render);
944    if (wantsHandoff.current && visualElement.animationState) {
945      visualElement.animationState.animateChanges();
946    }
947  });
948  (0, import_react22.useEffect)(() => {
949    if (!visualElement)
950      return;
951    if (!wantsHandoff.current && visualElement.animationState) {
952      visualElement.animationState.animateChanges();
953    }
954    if (wantsHandoff.current) {
955      queueMicrotask(() => {
956        var _a2;
957        (_a2 = window.MotionHandoffMarkAsComplete) === null || _a2 === void 0 ? void 0 : _a2.call(window, optimisedAppearId);
958      });
959      wantsHandoff.current = false;
960    }
961  });
962  return visualElement;
963}
964function createProjectionNode(visualElement, props, ProjectionNodeConstructor, initialPromotionConfig) {
965  const { layoutId, layout: layout2, drag: drag2, dragConstraints, layoutScroll, layoutRoot } = props;
966  visualElement.projection = new ProjectionNodeConstructor(visualElement.latestValues, props["data-framer-portal-id"] ? void 0 : getClosestProjectingNode(visualElement.parent));
967  visualElement.projection.setOptions({
968    layoutId,
969    layout: layout2,
970    alwaysMeasureLayout: Boolean(drag2) || dragConstraints && isRefObject(dragConstraints),
971    visualElement,
972    /**
973     * TODO: Update options in an effect. This could be tricky as it'll be too late
974     * to update by the time layout animations run.
975     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
976     * ensuring it gets called if there's no potential layout animations.
977     *
978     */
979    animationType: typeof layout2 === "string" ? layout2 : "both",
980    initialPromotionConfig,
981    layoutScroll,
982    layoutRoot
983  });
984}
985function getClosestProjectingNode(visualElement) {
986  if (!visualElement)
987    return void 0;
988  return visualElement.options.allowProjection !== false ? visualElement.projection : getClosestProjectingNode(visualElement.parent);
989}
990function createRendererMotionComponent({ preloadedFeatures, createVisualElement, useRender, useVisualState: useVisualState2, Component: Component3 }) {
991  var _a, _b;
992  preloadedFeatures && loadFeatures(preloadedFeatures);
993  function MotionComponent(props, externalRef) {
994    let MeasureLayout2;
995    const configAndProps = {
996      ...(0, import_react23.useContext)(MotionConfigContext),
997      ...props,
998      layoutId: useLayoutId(props)
999    };
1000    const { isStatic } = configAndProps;
1001    const context = useCreateMotionContext(props);
1002    const visualState = useVisualState2(props, isStatic);
1003    if (!isStatic && isBrowser) {
1004      useStrictMode(configAndProps, preloadedFeatures);
1005      const layoutProjection = getProjectionFunctionality(configAndProps);
1006      MeasureLayout2 = layoutProjection.MeasureLayout;
1007      context.visualElement = useVisualElement(Component3, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode);
1008    }
1009    return (0, import_jsx_runtime7.jsxs)(MotionContext.Provider, { value: context, children: [MeasureLayout2 && context.visualElement ? (0, import_jsx_runtime7.jsx)(MeasureLayout2, { visualElement: context.visualElement, ...configAndProps }) : null, useRender(Component3, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)] });
1010  }
1011  MotionComponent.displayName = `motion.${typeof Component3 === "string" ? Component3 : `

1011create(${(_b = (_a = Component3.displayName) !== null && _a !== void 0 ? _a : Component3.name) !== null && _b !== void 0 ? _b : ""})`}`;
1012  const ForwardRefMotionComponent = (0, import_react23.forwardRef)(MotionComponent);
1013  ForwardRefMotionComponent[motionComponentSymbol] = Component3;
1014  return ForwardRefMotionComponent;
1015}
1016function useLayoutId({ layoutId }) {
1017  const layoutGroupId = (0, import_react23.useContext)(LayoutGroupContext).id;
1018  return layoutGroupId && layoutId !== void 0 ? layoutGroupId + "-" + layoutId : layoutId;
1019}
1020function useStrictMode(configAndProps, preloadedFeatures) {
1021  const isStrict = (0, import_react23.useContext)(LazyContext).strict;
1022  if (preloadedFeatures && isStrict) {
1023    const strictMessage = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
1024    configAndProps.ignoreStrict ? warning(false, strictMessage) : invariant(false, strictMessage);
1025  }
1026}
1027function getProjectionFunctionality(props) {
1028  const { drag: drag2, layout: layout2 } = featureDefinitions;
1029  if (!drag2 && !layout2)
1030    return {};
1031  const combined = { ...drag2, ...layout2 };
1032  return {
1033    MeasureLayout: (drag2 === null || drag2 === void 0 ? void 0 : drag2.isEnabled(props)) || (layout2 === null || layout2 === void 0 ? void 0 : layout2.isEnabled(props)) ? combined.MeasureLayout : void 0,
1034    ProjectionNode: combined.ProjectionNode
1035  };
1036}
1037var import_dist157 = __toESM(require_dist(), 1);
1038var import_dist158 = __toESM(require_dist2(), 1);
1039var import_dist159 = __toESM(require_dist3(), 1);
1040var import_dist154 = __toESM(require_dist(), 1);
1041var import_dist155 = __toESM(require_dist2(), 1);
1042var import_dist156 = __toESM(require_dist3(), 1);
1043var lowercaseSVGElements = [
1044  "animate",
1045  "circle",
1046  "defs",
1047  "desc",
1048  "ellipse",
1049  "g",
1050  "image",
1051  "line",
1052  "filter",
1053  "marker",
1054  "mask",
1055  "metadata",
1056  "path",
1057  "pattern",
1058  "polygon",
1059  "polyline",
1060  "rect",
1061  "stop",
1062  "switch",
1063  "symbol",
1064  "svg",
1065  "text",
1066  "tspan",
1067  "use",
1068  "view"
1069];
1070function isSVGComponent(Component3) {
1071  if (
1072    /**
1073     * If it's not a string, it's a custom React component. Currently we only support
1074     * HTML custom React components.
1075     */
1076    typeof Component3 !== "string" || /**
1077    * If it contains a dash, the element is a custom HTML webcomponent.
1078    */
1079    Component3.includes("-")
1080  ) {
1081    return false;
1082  } else if (
1083    /**
1084     * If it's in our list of lowercase SVG tags, it's an SVG component
1085     */
1086    lowercaseSVGElements.indexOf(Component3) > -1 || /**
1087    * If it contains a capital letter, it's an SVG component
1088    */
1089    /[A-Z]/u.test(Component3)
1090  ) {
1091    return true;
1092  }
1093  return false;
1094}
1095var import_dist253 = __toESM(require_dist(), 1);
1096var import_dist254 = __toESM(require_dist2(), 1);
1097var import_dist255 = __toESM(require_dist3(), 1);
1098var import_dist175 = __toESM(require_dist(), 1);
1099var import_dist176 = __toESM(require_dist2(), 1);
1100var import_dist177 = __toESM(require_dist3(), 1);
1101var import_react24 = __toESM(require_react(), 1);
1102var import_dist160 = __toESM(require_dist(), 1);
1103var import_dist161 = __toESM(require_dist2(), 1);
1104var import_dist162 = __toESM(require_dist3(), 1);
1105function getValueState(visualElement) {
1106  const state2 = [{}, {}];
1107  visualElement === null || visualElement === void 0 ? void 0 : visualElement.values.forEach((value, key) => {
1108    state2[0][key] = value.get();
1109    state2[1][key] = value.getVelocity();
1110  });
1111  return state2;
1112}
1113function resolveVariantFromProps(props, definition, custom, visualElement) {
1114  if (typeof definition === "function") {
1115    const [current, velocity] = getValueState(visualElement);
1116    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
1117  }
1118  if (typeof definition === "string") {
1119    definition = props.variants && props.variants[definition];
1120  }
1121  if (typeof definition === "function") {
1122    const [current, velocity] = getValueState(visualElement);
1123    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
1124  }
1125  return definition;
1126}
1127var import_dist172 = __toESM(require_dist(), 1);
1128var import_dist173 = __toESM(require_dist2(), 1);
1129var import_dist174 = __toESM(require_dist3(), 1);
1130var import_dist166 = __toESM(require_dist(), 1);
1131var import_dist167 = __toESM(require_dist2(), 1);
1132var import_dist168 = __toESM(require_dist3(), 1);
1133var import_dist163 = __toESM(require_dist(), 1);
1134var import_dist164 = __toESM(require_dist2(), 1);
1135var import_dist165 = __toESM(require_dist3(), 1);
1136var isKeyframesTarget = (v) => {
1137  return Array.isArray(v);
1138};
1139var isCustomValue = (v) => {
1140  return Boolean(v && typeof v === "object" && v.mix && v.toValue);
1141};
1142var resolveFinalValueInKeyframes = (v) => {
1143  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
1144};
1145var import_dist169 = __toESM(require_dist(), 1);
1146var import_dist170 = __toESM(require_dist2(), 1);
1147var import_dist171 = __toESM(require_dist3(), 1);
1148var isMotionValue = (value) => Boolean(value && value.getVelocity);
1149function resolveMotionValue(value) {
1150  const unwrappedValue = isMotionValue(value) ? value.get() : value;
1151  return isCustomValue(unwrappedValue) ? unwrappedValue.toValue() : unwrappedValue;
1152}
1153function makeState({ scrapeMotionValuesFromProps: scrapeMotionValuesFromProps3, 

1153createRenderState, onUpdate }, props, context, presenceContext) {
1154  const state2 = {
1155    latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps3),
1156    renderState: createRenderState()
1157  };
1158  if (onUpdate) {
1159    state2.onMount = (instance) => onUpdate({ props, current: instance, ...state2 });
1160    state2.onUpdate = (visualElement) => onUpdate(visualElement);
1161  }
1162  return state2;
1163}
1164var makeUseVisualState = (config) => (props, isStatic) => {
1165  const context = (0, import_react24.useContext)(MotionContext);
1166  const presenceContext = (0, import_react24.useContext)(PresenceContext);
1167  const make = () => makeState(config, props, context, presenceContext);
1168  return isStatic ? make() : useConstant(make);
1169};
1170function makeLatestValues(props, context, presenceContext, scrapeMotionValues) {
1171  const values = {};
1172  const motionValues = scrapeMotionValues(props, {});
1173  for (const key in motionValues) {
1174    values[key] = resolveMotionValue(motionValues[key]);
1175  }
1176  let { initial, animate: animate2 } = props;
1177  const isControllingVariants$1 = isControllingVariants(props);
1178  const isVariantNode$1 = isVariantNode(props);
1179  if (context && isVariantNode$1 && !isControllingVariants$1 && props.inherit !== false) {
1180    if (initial === void 0)
1181      initial = context.initial;
1182    if (animate2 === void 0)
1183      animate2 = context.animate;
1184  }
1185  let isInitialAnimationBlocked = presenceContext ? presenceContext.initial === false : false;
1186  isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;
1187  const variantToSet = isInitialAnimationBlocked ? animate2 : initial;
1188  if (variantToSet && typeof variantToSet !== "boolean" && !isAnimationControls(variantToSet)) {
1189    const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];
1190    for (let i = 0; i < list.length; i++) {
1191      const resolved = resolveVariantFromProps(props, list[i]);
1192      if (resolved) {
1193        const { transitionEnd, transition, ...target } = resolved;
1194        for (const key in target) {
1195          let valueTarget = target[key];
1196          if (Array.isArray(valueTarget)) {
1197            const index = isInitialAnimationBlocked ? valueTarget.length - 1 : 0;
1198            valueTarget = valueTarget[index];
1199          }
1200          if (valueTarget !== null) {
1201            values[key] = valueTarget;
1202          }
1203        }
1204        for (const key in transitionEnd) {
1205          values[key] = transitionEnd[key];
1206        }
1207      }
1208    }
1209  }
1210  return values;
1211}
1212var import_dist178 = __toESM(require_dist(), 1);
1213var import_dist179 = __toESM(require_dist2(), 1);
1214var import_dist180 = __toESM(require_dist3(), 1);
1215var transformPropOrder = [
1216  "transformPerspective",
1217  "x",
1218  "y",
1219  "z",
1220  "translateX",
1221  "translateY",
1222  "translateZ",
1223  "scale",
1224  "scaleX",
1225  "scaleY",
1226  "rotate",
1227  "rotateX",
1228  "rotateY",
1229  "rotateZ",
1230  "skew",
1231  "skewX",
1232  "skewY"
1233];
1234var transformProps = new Set(transformPropOrder);
1235var import_dist220 = __toESM(require_dist(), 1);
1236var import_dist221 = __toESM(require_dist2(), 1);
1237var import_dist222 = __toESM(require_dist3(), 1);
1238var import_dist211 = __toESM(require_dist(), 1);
1239var import_dist212 = __toESM(require_dist2(), 1);
1240var import_dist213 = __toESM(require_dist3(), 1);
1241var import_dist181 = __toESM(require_dist(), 1);
1242var import_dist182 = __toESM(require_dist2(), 1);
1243var import_dist183 = __toESM(require_dist3(), 1);
1244var checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
1245var isCSSVariableName = checkStringStartsWith("--");
1246var startsAsVariableToken = checkStringStartsWith("var(--");
1247var isCSSVariableToken = (value) => {
1248  const startsWithToken = startsAsVariableToken(value);
1249  if (!startsWithToken)
1250    return false;
1251  return singleCssVariableRegex.test(value.split("/*")[0].trim());
1252};
1253var singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
1254var import_dist184 = __toESM(require_dist(), 1);
1255var import_dist185 = __toESM(require_dist2(), 1);
1256var import_dist186 = __toESM(require_dist3(), 1);
1257var getValueAsType = (value, type) => {
1258  return type && typeof value === "number" ? type.transform(value) : value;
1259};
1260var import_dist205 = __toESM(require_dist(), 1);
1261var import_dist206 = __toESM(require_dist2(), 1);
1262var import_dist207 = __toESM(require_dist3(), 1);
1263var import_dist190 = __toESM(require_dist(), 1);
1264var import_dist191 = __toESM(require_dist2(), 1);
1265var import_dist192 = __toESM(require_dist3(), 1);
1266var import_dist187 = __toESM(require_dist(), 1);
1267var import_dist188 = __toESM(require_dist2(), 1);
1268var import_dist189 = __toESM(require_dist3(), 1);
1269var clamp = (min, max, v) => {
1270  if (v > max)
1271    return max;
1272  if (v < min)
1273    return min;
1274  return v;
1275};
1276var number = {
1277  test: (v) => typeof v === "number",
1278  parse: parseFloat,
1279  transform: (v) => v
1280};
1281var alpha = {
1282  ...number,
1283  transform: (v) => clamp(0, 1, v)
1284};
1285var scale = {
1286  ...number,
1287  default: 1
1288};
1289var import_dist193 = __toESM(require_dist(), 1);
1290var import_dist194 = __toESM(require_dist2(), 1);
1291var import_dist195 = __toESM(require_dist3(), 1);
1292var createUnitType = (unit) => ({
1293  test: (v) => typeof v === "string" && v.endsWith(unit) && v.split(" ").length === 1,
1294  parse: parseFloat,
1295  transform: (v) => `${v}${unit}`
1296});
1297var degrees = createUnitType("deg");
1298var percent = createUnitType("%");
1299var px = createUnitType("px");
1300var vh = createUnitType("vh");
1301var vw = createUnitType("vw");
1302var progressPercentage = {
1303  ...percent,
1304  parse: (v) => percent.parse(v) / 100,
1305  transform: (v) => percent.transform(v * 100)
1306};
1307var import_dist196 = __toESM(require_dist(), 1);
1308var import_dist197 = __toESM(require_dist2(), 1);
1309var import_dist198 = __toESM(require_dist3(), 1);
1310var browserNumberValueTypes = {
1311  // Border props
1312  borderWidth: px,
1313  borderTopWidth: px,
1314  borderRightWidth: px,
1315  borderBottomWidth: px,
1316  borderLeftWidth: px,
1317  borderRadius: px,
1318  radius: px,
1319  borderTopLeftRadius: px,
1320  borderTopRightRadius: px,
1321  borderBottomRightRadius: px,
1322  borderBottomLeftRadius: px,
1323  // Positioning props
1324  width: px,
1325  maxWidth: px,
1326  height: px,
1327  maxHeight: px,
1328  top: px,
1329  right: px,
1330  bottom: px,
1331  left: px,
1332  // Spacing props
1333  padding: px,
1334  paddingTop: px,
1335  paddingRight: px,
1336  paddingBottom: px,
1337  paddingLeft: px,
1338  margin: px,
1339  marginTop: px,
1340  marginRight: px,
1341  marginBottom: px,
1342  marginLeft: px,
1343  // Misc
1344  backgroundPositionX: px,
1345  backgroundPositionY: px
1346};
1347var import_dist199 = __toESM(require_dist(), 1);
1348var import_dist200 = __toESM(require_dist2(), 1);
1349var import_dist201 = __toESM(require_dist3(), 1);
1350var transformValueTypes = {
1351  rotate: degrees,
1352  rotateX: degrees,
1353  rotateY: degrees,
1354  rotateZ: degrees,
1355  scale,
1356  scaleX: scale,
1357  scaleY: scale,
1358  scaleZ: scale,
1359  skew: degrees,
1360  skewX: degrees,
1361  skewY: degrees,
1362  distance: px,
1363  translateX: px,
1364  translateY: px,
1365  translateZ: px,
1366  x: px,
1367  y: px,
1368  z: px,
1369  perspective: px,
1370  transformPerspective: px,
1371  opacity: alpha,
1372  originX: progressPercentage,
1373  originY: progressPercentage,
1374  originZ: px
1375};
1376var import_dist202 = __toESM(require_dist(), 1);
1377var import_dist203 = __toESM(require_dist2(), 1);
1378var import_dist204 = __toESM(require_dist3(), 1);
1379var int = {
1380  ...number,
1381  transform: Math.round
1382};
1383var numberValueTypes = {
1384  ...browserNumberValueTypes,
1385  ...transformValueTypes,
1386  zIndex: int,
1387  size: px,
1388  // SVG
1389  fillOpacity: alpha,
1390  strokeOpacity: alpha,
1391  numOctaves: int
1392};
1393var import_dist208 = __toESM(require_dist(), 1);
1394var import_dist209 = __toESM(require_dist2(), 1);
1395var import_dist210 = __toESM(require_dist3(), 1);
1396var translateAlias = {
1397  x: "translateX",
1398  y: "translateY",
1399  z: "translateZ",
1400  transformPerspective: "perspective"
1401};
1402var numTransforms = transformPropOrder.length;
1403function buildTransform(latestValues, transform2, transformTemplate) {
1404  let transformString = "";
1405  let transformIsDefault = true;
1406  for (let i = 0; i < numTransforms; i++) {

1407    const key = transformPropOrder[i];
1408    const value = latestValues[key];
1409    if (value === void 0)
1410      continue;
1411    let valueIsDefault = true;
1412    if (typeof value === "number") {
1413      valueIsDefault = value === (key.startsWith("scale") ? 1 : 0);
1414    } else {
1415      valueIsDefault = parseFloat(value) === 0;
1416    }
1417    if (!valueIsDefault || transformTemplate) {
1418      const valueAsType = getValueAsType(value, numberValueTypes[key]);
1419      if (!valueIsDefault) {
1420        transformIsDefault = false;
1421        const transformName = translateAlias[key] || key;
1422        transformString += `${transformName}(${valueAsType}) `;
1423      }
1424      if (transformTemplate) {
1425        transform2[key] = valueAsType;
1426      }
1427    }
1428  }
1429  transformString = transformString.trim();
1430  if (transformTemplate) {
1431    transformString = transformTemplate(transform2, transformIsDefault ? "" : transformString);
1432  } else if (transformIsDefault) {
1433    transformString = "none";
1434  }
1435  return transformString;
1436}
1437function buildHTMLStyles(state2, latestValues, transformTemplate) {
1438  const { style, vars, transformOrigin } = state2;
1439  let hasTransform2 = false;
1440  let hasTransformOrigin = false;
1441  for (const key in latestValues) {
1442    const value = latestValues[key];
1443    if (transformProps.has(key)) {
1444      hasTransform2 = true;
1445      continue;
1446    } else if (isCSSVariableName(key)) {
1447      vars[key] = value;
1448      continue;
1449    } else {
1450      const valueAsType = getValueAsType(value, numberValueTypes[key]);
1451      if (key.startsWith("origin")) {
1452        hasTransformOrigin = true;
1453        transformOrigin[key] = valueAsType;
1454      } else {
1455        style[key] = valueAsType;
1456      }
1457    }
1458  }
1459  if (!latestValues.transform) {
1460    if (hasTransform2 || transformTemplate) {
1461      style.transform = buildTransform(latestValues, state2.transform, transformTemplate);
1462    } else if (style.transform) {
1463      style.transform = "none";
1464    }
1465  }
1466  if (hasTransformOrigin) {
1467    const { originX = "50%", originY = "50%", originZ = 0 } = transformOrigin;
1468    style.transformOrigin = `${originX} ${originY} ${originZ}`;
1469  }
1470}
1471var import_dist214 = __toESM(require_dist(), 1);
1472var import_dist215 = __toESM(require_dist2(), 1);
1473var import_dist216 = __toESM(require_dist3(), 1);
1474var dashKeys = {
1475  offset: "stroke-dashoffset",
1476  array: "stroke-dasharray"
1477};
1478var camelKeys = {
1479  offset: "strokeDashoffset",
1480  array: "strokeDasharray"
1481};
1482function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
1483  attrs.pathLength = 1;
1484  const keys2 = useDashCase ? dashKeys : camelKeys;
1485  attrs[keys2.offset] = px.transform(-offset);
1486  const pathLength = px.transform(length);
1487  const pathSpacing = px.transform(spacing);
1488  attrs[keys2.array] = `${pathLength} ${pathSpacing}`;
1489}
1490var import_dist217 = __toESM(require_dist(), 1);
1491var import_dist218 = __toESM(require_dist2(), 1);
1492var import_dist219 = __toESM(require_dist3(), 1);
1493function calcOrigin(origin, offset, size) {
1494  return typeof origin === "string" ? origin : px.transform(offset + size * origin);
1495}
1496function calcSVGTransformOrigin(dimensions, originX, originY) {
1497  const pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);
1498  const pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);
1499  return `${pxOriginX} ${pxOriginY}`;
1500}
1501function buildSVGAttrs(state2, {
1502  attrX,
1503  attrY,
1504  attrScale,
1505  originX,
1506  originY,
1507  pathLength,
1508  pathSpacing = 1,
1509  pathOffset = 0,
1510  // This is object creation, which we try to avoid per-frame.
1511  ...latest
1512}, isSVGTag2, transformTemplate) {
1513  buildHTMLStyles(state2, latest, transformTemplate);
1514  if (isSVGTag2) {
1515    if (state2.style.viewBox) {
1516      state2.attrs.viewBox = state2.style.viewBox;
1517    }
1518    return;
1519  }
1520  state2.attrs = state2.style;
1521  state2.style = {};
1522  const { attrs, style, dimensions } = state2;
1523  if (attrs.transform) {
1524    if (dimensions)
1525      style.transform = attrs.transform;
1526    delete attrs.transform;
1527  }
1528  if (dimensions && (originX !== void 0 || originY !== void 0 || style.transform)) {
1529    style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== void 0 ? originX : 0.5, originY !== void 0 ? originY : 0.5);
1530  }
1531  if (attrX !== void 0)
1532    attrs.x = attrX;
1533  if (attrY !== void 0)
1534    attrs.y = attrY;
1535  if (attrScale !== void 0)
1536    attrs.scale = attrScale;

1537  if (pathLength !== void 0) {
1538    buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
1539  }
1540}
1541var import_dist226 = __toESM(require_dist(), 1);
1542var import_dist227 = __toESM(require_dist2(), 1);
1543var import_dist228 = __toESM(require_dist3(), 1);
1544var import_dist223 = __toESM(require_dist(), 1);
1545var import_dist224 = __toESM(require_dist2(), 1);
1546var import_dist225 = __toESM(require_dist3(), 1);
1547var createHtmlRenderState = () => ({
1548  style: {},
1549  transform: {},
1550  transformOrigin: {},
1551  vars: {}
1552});
1553var createSvgRenderState = () => ({
1554  ...createHtmlRenderState(),
1555  attrs: {}
1556});
1557var import_dist229 = __toESM(require_dist(), 1);
1558var import_dist230 = __toESM(require_dist2(), 1);
1559var import_dist231 = __toESM(require_dist3(), 1);
1560var isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
1561var import_dist238 = __toESM(require_dist(), 1);
1562var import_dist239 = __toESM(require_dist2(), 1);
1563var import_dist240 = __toESM(require_dist3(), 1);
1564var import_dist232 = __toESM(require_dist(), 1);
1565var import_dist233 = __toESM(require_dist2(), 1);
1566var import_dist234 = __toESM(require_dist3(), 1);
1567function renderHTML(element, { style, vars }, styleProp, projection) {
1568  Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));
1569  for (const key in vars) {
1570    element.style.setProperty(key, vars[key]);
1571  }
1572}
1573var import_dist235 = __toESM(require_dist(), 1);
1574var import_dist236 = __toESM(require_dist2(), 1);
1575var import_dist237 = __toESM(require_dist3(), 1);
1576var camelCaseAttributes = /* @__PURE__ */ new Set([
1577  "baseFrequency",
1578  "diffuseConstant",
1579  "kernelMatrix",
1580  "kernelUnitLength",
1581  "keySplines",
1582  "keyTimes",
1583  "limitingConeAngle",
1584  "markerHeight",
1585  "markerWidth",
1586  "numOctaves",
1587  "targetX",
1588  "targetY",
1589  "surfaceScale",
1590  "specularConstant",
1591  "specularExponent",
1592  "stdDeviation",
1593  "tableValues",
1594  "viewBox",
1595  "gradientTransform",
1596  "pathLength",
1597  "startOffset",
1598  "textLength",
1599  "lengthAdjust"
1600]);

1601function renderSVG(element, renderState, _styleProp, projection) {
1602  renderHTML(element, renderState, void 0, projection);
1603  for (const key in renderState.attrs) {
1604    element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
1605  }
1606}
1607var import_dist250 = __toESM(require_dist(), 1);
1608var import_dist251 = __toESM(require_dist2(), 1);
1609var import_dist252 = __toESM(require_dist3(), 1);
1610var import_dist247 = __toESM(require_dist(), 1);
1611var import_dist248 = __toESM(require_dist2(), 1);
1612var import_dist249 = __toESM(require_dist3(), 1);
1613var import_dist244 = __toESM(require_dist(), 1);
1614var import_dist245 = __toESM(require_dist2(), 1);
1615var import_dist246 = __toESM(require_dist3(), 1);
1616var import_dist241 = __toESM(require_dist(), 1);
1617var import_dist242 = __toESM(require_dist2(), 1);
1618var import_dist243 = __toESM(require_dist3(), 1);
1619var scaleCorrectors = {};
1620function addScaleCorrector(correctors) {
1621  Object.assign(scaleCorrectors, correctors);
1622}
1623function isForcedMotionValue(key, { layout: layout2, layoutId }) {
1624  return transformProps.has(key) || key.startsWith("origin") || (layout2 || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
1625}
1626function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
1627  var _a;
1628  const { style } = props;
1629  const newValues = {};
1630  for (const key in style) {
1631    if (isMotionValue(style[key]) || prevProps.style && isMotionValue(prevProps.style[key]) || isForcedMotionValue(key, props) || ((_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.liveStyle) !== void 0) {
1632      newValues[key] = style[key];
1633    }
1634  }
1635  return newValues;
1636}
1637function scrapeMotionValuesFromProps2(props, prevProps, visualElement) {
1638  const newValues = scrapeMotionValuesFromProps(props, prevProps, visualElement);
1639  for (const key in props) {
1640    if (isMotionValue(props[key]) || isMotionValue(prevProps[key])) {
1641      const targetKey = transformPropOrder.indexOf(key) !== -1 ? "attr" + key.charAt(0).toUpperCase() + key.substring(1) : key;
1642      newValues[targetKey] = props[key];
1643    }
1644  }
1645  return newValues;
1646}
1647function updateSVGDimensions(instance, renderState) {
1648  try {
1649    renderState.dimensions = typeof instance.getBBox === "function" ? instance.getBBox() : instance.getBoundingClientRect();
1650  } catch (e) {
1651    renderState.dimensions = {
1652      x: 0,
1653      y: 0,
1654      width: 0,
1655      height: 0
1656    };
1657  }
1658}
1659var layoutProps = ["x", "y", "width", "height", "cx", "cy", "r"];
1660var svgMotionConfig = {
1661  useVisualState: makeUseVisualState({
1662    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps2,
1663    createRenderState: createSvgRenderState,
1664    onUpdate: ({ props, prevProps, current, renderState, latestValues }) => {
1665      if (!current)
1666        return;
1667      let hasTransform2 = !!props.drag;
1668      if (!hasTransform2) {
1669        for (const key in latestValues) {
1670          if (transformProps.has(key)) {
1671            hasTransform2 = true;
1672            break;
1673          }
1674        }
1675      }
1676      if (!hasTransform2)
1677        return;
1678      let needsMeasure = !prevProps;
1679      if (prevProps) {
1680        for (let i = 0; i < layoutProps.length; i++) {
1681          const key = layoutProps[i];
1682          if (props[key] !== prevProps[key]) {
1683            needsMeasure = true;
1684          }
1685        }
1686      }
1687      if (!needsMeasure)
1688        return;
1689      frame.read(() => {
1690        updateSVGDimensions(current, renderState);
1691        frame.render(() => {
1692          buildSVGAttrs(renderState, latestValues, isSVGTag(current.tagName), props.transformTemplate);
1693          renderSVG(current, renderState);
1694        });
1695      });
1696    }
1697  })
1698};
1699var import_dist256 = __toESM(require_dist(), 1);
1700var import_dist257 = __toESM(require_dist2(), 1);
1701var import_dist258 = __toESM(require_dist3(), 1);
1702var htmlMotionConfig = {
1703  useVisualState: makeUseVisualState({
1704    scrapeMotionValuesFromProps,
1705    createRenderState: createHtmlRenderState
1706  })
1707};
1708var import_dist265 = __toESM(require_dist(), 1);
1709var import_dist266 = __toESM(require_dist2(), 1);
1710var import_dist267 = __toESM(require_dist3(), 1);
1711var import_react27 = __toESM(require_react(), 1);
1712var import_dist259 = __toESM(require_dist(), 1);
1713var import_dist260 = __toESM(require_dist2(), 1);
1714var import_dist261 = __toESM(require_dist3(), 1);
1715var import_react25 = __toESM(require_react(), 1);
1716function copyRawValuesOnly(target, source, props) {
1717  for (const key in source) {
1718    if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {
1719      target[key] = source[key];
1720    }
1721  }
1722}
1723function useInitialMotionValues({ transformTemplate }, visualState) {
1724  return (0, import_react25.useMemo)(() => {
1725    const state2 = createHtmlRenderState();
1726    buildHTMLStyles(state2, visualState, transformTemplate);
1727    return Object.assign({}, state2.vars, state2.style);
1728  }, [visualState]);
1729}
1730function useStyle(props, visualState) {
1731  const styleProp = props.style || {};
1732  const style = {};
1733  copyRawValuesOnly(style, styleProp, props);
1734  Object.assign(style, useInitialMotionValues(props, visualState));
1735  return style;
1736}
1737function useHTMLProps(props, visualState) {
1738  const htmlProps = {};
1739  const style = useStyle(props, visualState);
1740  if (props.drag && props.dragListener !== false) {
1741    htmlProps.draggable = false;

1742    style.userSelect = style.WebkitUserSelect = style.WebkitTouchCallout = "none";
1743    style.touchAction = props.drag === true ? "none" : `pan-${props.drag === "x" ? "y" : "x"}`;
1744  }
1745  if (props.tabIndex === void 0 && (props.onTap || props.onTapStart || props.whileTap)) {
1746    htmlProps.tabIndex = 0;
1747  }
1748  htmlProps.style = style;
1749  return htmlProps;
1750}
1751var import_dist262 = __toESM(require_dist(), 1);
1752var import_dist263 = __toESM(require_dist2(), 1);
1753var import_dist264 = __toESM(require_dist3(), 1);
1754var import_react26 = __toESM(require_react(), 1);
1755function useSVGProps(props, visualState, _isStatic, Component3) {
1756  const visualProps = (0, import_react26.useMemo)(() => {
1757    const state2 = createSvgRenderState();
1758    buildSVGAttrs(state2, visualState, isSVGTag(Component3), props.transformTemplate);
1759    return {
1760      ...state2.attrs,
1761      style: { ...state2.style }
1762    };
1763  }, [visualState]);
1764  if (props.style) {
1765    const rawStyles = {};
1766    copyRawValuesOnly(rawStyles, props.style, props);
1767    visualProps.style = { ...rawStyles, ...visualProps.style };
1768  }
1769  return visualProps;
1770}
1771function createUseRender(forwardMotionProps = false) {
1772  const useRender = (Component3, props, ref, { latestValues }, isStatic) => {
1773    const useVisualProps = isSVGComponent(Component3) ? useSVGProps : useHTMLProps;
1774    const visualProps = useVisualProps(props, latestValues, isStatic, Component3);
1775    const filteredProps = filterProps(props, typeof Component3 === "string", forwardMotionProps);
1776    const elementProps = Component3 !== import_react27.Fragment ? { ...filteredProps, ...visualProps, ref } : {};
1777    const { children } = props;
1778    const renderedChildren = (0, import_react27.useMemo)(() => isMotionValue(children) ? children.get() : children, [children]);
1779    return (0, import_react27.createElement)(Component3, {
1780      ...elementProps,
1781      children: renderedChildren
1782    });
1783  };
1784  return useRender;
1785}
1786function createMotionComponentFactory(preloadedFeatures, createVisualElement) {
1787  return function createMotionComponent2(Component3, { forwardMotionProps } = { forwardMotionProps: false }) {
1788    const baseConfig = isSVGComponent(Component3) ? svgMotionConfig : htmlMotionConfig;
1789    const config = {
1790      ...baseConfig,
1791      preloadedFeatures,
1792      useRender: createUseRender(forwardMotionProps),
1793      createVisualElement,
1794      Component: Component3
1795    };
1796    return createRendererMotionComponent(config);
1797  };
1798}
1799var createMinimalMotionComponent = createMotionComponentFactory();
1800var m = createDOMMotionComponentProxy(createMinimalMotionComponent);
1801var import_dist808 = __toESM(require_dist(), 1);
1802var import_dist809 = __toESM(require_dist2(), 1);
1803var import_dist810 = __toESM(require_dist3(), 1);
1804var import_dist805 = __toESM(require_dist(), 1);
1805var import_dist806 = __toESM(require_dist2(), 1);
1806var import_dist807 = __toESM(require_dist3(), 1);
1807var import_dist643 = __toESM(require_dist(), 1);
1808var import_dist644 = __toESM(require_dist2(), 1);
1809var import_dist645 = __toESM(require_dist3(), 1);
1810var import_dist637 = __toESM(require_dist(), 1);
1811var import_dist638 = __toESM(require_dist2(), 1);
1812var import_dist639 = __toESM(require_dist3(), 1);
1813var import_dist631 = __toESM(require_dist(), 1);
1814var import_dist632 = __toESM(require_dist2(), 1);
1815var import_dist633 = __toESM(require_dist3(), 1);
1816var import_dist277 = __toESM(require_dist(), 1);
1817var import_dist278 = __toESM(require_dist2(), 1);
1818var import_dist279 = __toESM(require_dist3(), 1);
1819function shallowCompare(next, prev) {
1820  if (!Array.isArray(prev))
1821    return false;
1822  const prevLength = prev.length;
1823  if (prevLength !== next.length)
1824    return false;
1825  for (let i = 0; i < prevLength; i++) {
1826    if (prev[i] !== next[i])
1827      return false;
1828  }
1829  return true;
1830}
1831var import_dist280 = __toESM(require_dist(), 1);
1832var import_dist281 = __toESM(require_dist2(), 1);
1833var import_dist282 = __toESM(require_dist3(), 1);
1834function resolveVariant(visualElement, definition, custom) {
1835  const props = visualElement.getProps();
1836  return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
1837}
1838var import_dist625 = __toESM(require_dist(), 1);
1839var import_dist626 = __toESM(require_dist2(), 1);
1840var import_dist627 = __toESM(require_dist3(), 1);
1841var import_dist619 = __toESM(require_dist(), 1);
1842var import_dist620 = __toESM(require_dist2(), 1);
1843var import_dist621 = __toESM(require_dist3(), 1);
1844var import_dist388 = __toESM(require_dist(), 1);
1845var import_dist389 = __toESM(require_dist2(), 1);
1846var import_dist390 = __toESM(require_dist3(), 1);
1847var import_dist289 = __toESM(require_dist(), 1);
1848var import_dist290 = __toESM(require_dist2(), 1);
1849var import_dist291 = __toESM(require_dist3(), 1);
1850var import_dist286 = __toESM(require_dist(), 1);
1851var import_dist287 = __toESM(require_dist2(), 1);
1852var import_dist288 = __toESM(require_dist3(), 1);
1853var import_dist283 = __toESM(require_dist(), 1);
1854var import_dist284 = __toESM(require_dist2(), 1);
1855var import_dist285 = __toESM(require_dist3(), 1);
1856var supportsScrollTimeline = memo(() => window.ScrollTimeline !== void 0);
1857var BaseGroupPlaybackControls = class {
1858  constructor(animations2) {
1859    this.stop = () => this.runAll("stop");
1860    this.animations = animations2.filter(Boolean);
1861  }
1862  get finished() {
1863    return Promise.all(this.animations.map((animation) => "finished" in animation ? animation.finished : animation));
1864  }
1865  /**
1866   * TODO: Filter out cancelled or stopped animations before returning
1867   */
1868  getAll(propName) {
1869    return this.animations[0][propName];
1870  }
1871  setAll(propName, newValue) {
1872    for (let i = 0; i < this.animations.length; i++) {
1873      this.animations[i][propName] = newValue;
1874    }
1875  }
1876  attachTimeline(timeline, fallback) {
1877    const subscriptions = this.animations.map((animation) => {
1878      if (supportsScrollTimeline() && animation.attachTimeline) {
1879        return animation.attachTimeline(timeline);
1880      } else if (typeof fallback === "function") {
1881        return fallback(animation);
1882      }
1883    });
1884    return () => {
1885      subscriptions.forEach((cancel, i) => {
1886        cancel && cancel();
1887        this.animations[i].stop();
1888      });
1889    };
1890  }
1891  get time() {
1892    return this.getAll("time");
1893  }
1894  set time(time2) {
1895    this.setAll("time", time2);
1896  }
1897  get speed() {
1898    return this.getAll("speed");
1899  }
1900  set speed(speed) {
1901    this.setAll("speed", speed);
1902  }
1903  get startTime() {
1904    return this.getAll("startTime");
1905  }
1906  get duration() {
1907    let max = 0;
1908    for (let i = 0; i < this.animations.length; i++) {
1909      max = Math.max(max, this.animations[i].duration);
1910    }
1911    return max;
1912  }
1913  runAll(methodName) {
1914    this.animations.forEach((controls) => controls[methodName]());
1915  }
1916  flatten() {
1917    this.runAll("flatten");
1918  }
1919  play() {
1920    this.runAll("play");
1921  }
1922  pause() {
1923    this.runAll("pause");
1924  }
1925  cancel() {
1926    this.runAll("cancel");
1927  }
1928  complete() {
1929    this.runAll("complete");
1930  }
1931};
1932var GroupPlaybackControls = class extends BaseGroupPlaybackControls {
1933  then(onResolve, onReject) {

1934    return Promise.all(this.animations).then(onResolve).catch(onReject);
1935  }
1936};
1937var import_dist292 = __toESM(require_dist(), 1);
1938var import_dist293 = __toESM(require_dist2(), 1);
1939var import_dist294 = __toESM(require_dist3(), 1);
1940function getValueTransition(transition, key) {
1941  return transition ? transition[key] || transition["default"] || transition : void 0;
1942}
1943var import_dist295 = __toESM(require_dist(), 1);
1944var import_dist296 = __toESM(require_dist2(), 1);
1945var import_dist297 = __toESM(require_dist3(), 1);
1946var maxGeneratorDuration = 2e4;
1947function calcGeneratorDuration(generator) {
1948  let duration = 0;
1949  const timeStep = 50;
1950  let state2 = generator.next(duration);
1951  while (!state2.done && duration < maxGeneratorDuration) {
1952    duration += timeStep;
1953    state2 = generator.next(duration);
1954  }
1955  return duration >= maxGeneratorDuration ? Infinity : duration;
1956}
1957var import_dist298 = __toESM(require_dist(), 1);
1958var import_dist299 = __toESM(require_dist2(), 1);
1959var import_dist300 = __toESM(require_dist3(), 1);
1960function createGeneratorEasing(options, scale2 = 100, createGenerator) {
1961  const generator = createGenerator({ ...options, keyframes: [0, scale2] });
1962  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
1963  return {
1964    type: "keyframes",
1965    ease: (progress2) => {
1966      return generator.next(duration * progress2).value / scale2;
1967    },
1968    duration: millisecondsToSeconds(duration)
1969  };
1970}
1971var import_dist301 = __toESM(require_dist(), 1);
1972var import_dist302 = __toESM(require_dist2(), 1);
1973var import_dist303 = __toESM(require_dist3(), 1);
1974function isGenerator(type) {
1975  return typeof type === "function";
1976}
1977var import_dist307 = __toESM(require_dist(), 1);
1978var import_dist308 = __toESM(require_dist2(), 1);
1979var import_dist309 = __toESM(require_dist3(), 1);
1980var import_dist304 = __toESM(require_dist(), 1);
1981var import_dist305 = __toESM(require_dist2(), 1);
1982var import_dist306 = __toESM(require_dist3(), 1);
1983function attachTimeline(animation, timeline) {
1984  animation.timeline = timeline;
1985  animation.onfinish = null;
1986}
1987var NativeAnimationControls = class {
1988  constructor(animation) {
1989    this.animation = animation;
1990  }
1991  get duration() {
1992    var _a, _b, _c;
1993    const durationInMs = ((_b = (_a = this.animation) === null || _a === void 0 ? void 0 : _a.effect) === null || _b === void 0 ? void 0 : _b.getComputedTiming().duration) || ((_c = this.options) === null || _c === void 0 ? void 0 : _c.duration) || 300;
1994    return millisecondsToSeconds(Number(durationInMs));
1995  }
1996  get time() {
1997    var _a;
1998    if (this.animation) {
1999      return millisecondsToSeconds(((_a = this.animation) === null || _a === void 0 ? void 0 : _a.currentTime) || 0);
2000    }
2001    return 0;
2002  }
2003  set time(newTime) {
2004    if (this.animation) {
2005      this.animation.currentTime = secondsToMilliseconds(newTime);
2006    }
2007  }
2008  get speed() {
2009    return this.animation ? this.animation.playbackRate : 1;
2010  }
2011  set speed(newSpeed) {
2012    if (this.animation) {
2013      this.animation.playbackRate = newSpeed;
2014    }
2015  }
2016  get state() {
2017    return this.animation ? this.animation.playState : "finished";
2018  }
2019  get startTime() {
2020    return this.animation ? this.animation.startTime : null;
2021  }
2022  get finished() {
2023    return this.animation ? this.animation.finished : Promise.resolve();
2024  }
2025  play() {
2026    this.animation && this.animation.play();
2027  }
2028  pause() {
2029    this.animation && this.animation.pause();
2030  }
2031  stop() {
2032    if (!this.animation || this.state === "idle" || this.state === "finished") {
2033      return;
2034    }
2035    if (this.animation.commitStyles) {
2036      this.animation.commitStyles();
2037    }
2038    this.cancel();
2039  }
2040  flatten() {
2041    var _a;
2042    if (!this.animation)
2043      return;
2044    (_a = this.animation.effect) === null || _a === void 0 ? void 0 : _a.updateTiming({ easing: "linear" });
2045  }
2046  attachTimeline(timeline) {
2047    if (this.animation)
2048      attachTimeline(this.animation, timeline);
2049    return noop;
2050  }
2051  complete() {
2052    this.animation && this.animation.finish();
2053  }
2054  cancel() {
2055    try {
2056      this.animation && this.animation.cancel();
2057    } catch (e) {
2058    }
2059  }
2060};
2061var import_dist325 = __toESM(require_dist(), 1);
2062var import_dist326 = __toESM(require_dist2(), 1);
2063var import_dist327 = __toESM(require_dist3(), 1);
2064var import_dist310 = __toESM(require_dist(), 1);
2065var import_dist311 = __toESM(require_dist2(), 1);
2066var import_dist312 = __toESM(require_dist3(), 1);
2067var isBezierDefinition = (easing) =>

2067 Array.isArray(easing) && typeof easing[0] === "number";
2068var import_dist319 = __toESM(require_dist(), 1);
2069var import_dist320 = __toESM(require_dist2(), 1);
2070var import_dist321 = __toESM(require_dist3(), 1);
2071var import_dist316 = __toESM(require_dist(), 1);
2072var import_dist317 = __toESM(require_dist2(), 1);
2073var import_dist318 = __toESM(require_dist3(), 1);
2074var import_dist313 = __toESM(require_dist(), 1);
2075var import_dist314 = __toESM(require_dist2(), 1);
2076var import_dist315 = __toESM(require_dist3(), 1);
2077var supportsFlags = {
2078  linearEasing: void 0
2079};
2080function memoSupports(callback, supportsFlag) {
2081  const memoized = memo(callback);
2082  return () => {
2083    var _a;
2084    return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized();
2085  };
2086}
2087var supportsLinearEasing = memoSupports(() => {
2088  try {
2089    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
2090  } catch (e) {
2091    return false;
2092  }
2093  return true;
2094}, "linearEasing");
2095var import_dist322 = __toESM(require_dist(), 1);
2096var import_dist323 = __toESM(require_dist2(), 1);
2097var import_dist324 = __toESM(require_dist3(), 1);
2098var generateLinearEasing = (easing, duration, resolution = 10) => {
2099  let points = "";

2100  const numPoints = Math.max(Math.round(duration / resolution), 2);
2101  for (let i = 0; i < numPoints; i++) {
2102    points += easing(progress(0, numPoints - 1, i)) + ", ";
2103  }
2104  return `linear(${points.substring(0, points.length - 2)})`;
2105};
2106function isWaapiSupportedEasing(easing) {
2107  return Boolean(typeof easing === "function" && supportsLinearEasing() || !easing || typeof easing === "string" && (easing in supportedWaapiEasing || supportsLinearEasing()) || isBezierDefinition(easing) || Array.isArray(easing) && easing.every(isWaapiSupportedEasing));
2108}
2109var cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
2110var supportedWaapiEasing = {
2111  linear: "linear",
2112  ease: "ease",
2113  easeIn: "ease-in",
2114  easeOut: "ease-out",
2115  easeInOut: "ease-in-out",
2116  circIn: cubicBezierAsString([0, 0.65, 0.55, 1]),
2117  circOut: cubicBezierAsString([0.55, 0, 1, 0.45]),
2118  backIn: cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
2119  backOut: cubicBezierAsString([0.33, 1.53, 0.69, 0.99])
2120};
2121function mapEasingToNativeEasing(easing, duration) {
2122  if (!easing) {
2123    return void 0;
2124  } else if (typeof easing === "function" && supportsLinearEasing()) {
2125    return generateLinearEasing(easing, duration);
2126  } else if (isBezierDefinition(easing)) {
2127    return cubicBezierAsString(easing);
2128  } else if (Array.isArray(easing)) {
2129    return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) || supportedWaapiEasing.easeOut);
2130  } else {
2131    return supportedWaapiEasing[easing];
2132  }
2133}
2134var import_dist337 = __toESM(require_dist(), 1);
2135var import_dist338 = __toESM(require_dist2(), 1);
2136var import_dist339 = __toESM(require_dist3(), 1);
2137var import_dist328 = __toESM(require_dist(), 1);
2138var import_dist329 = __toESM(require_dist2(), 1);
2139var import_dist330 = __toESM(require_dist3(), 1);
2140var isDragging = {
2141  x: false,
2142  y: false
2143};
2144function isDragActive() {
2145  return isDragging.x || isDragging.y;
2146}
2147var import_dist334 = __toESM(require_dist(), 1);
2148var import_dist335 = __toESM(require_dist2(), 1);
2149var import_dist336 = __toESM(require_dist3(), 1);
2150var import_dist331 = __toESM(require_dist(), 1);
2151var import_dist332 = __toESM(require_dist2(), 1);
2152var import_dist333 = __toESM(require_dist3(), 1);
2153function resolveElements(elementOrSelector, scope, selectorCache) {
2154  var _a;
2155  if (elementOrSelector instanceof Element) {
2156    return [elementOrSelector];
2157  } else if (typeof elementOrSelector === "string") {
2158    let root = document;
2159    if (scope) {
2160      root = scope.current;
2161    }
2162    const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);
2163    return elements ? Array.from(elements) : [];
2164  }
2165  return Array.from(elementOrSelector);
2166}
2167function setupGesture(elementOrSelector, options) {
2168  const elements = resolveElements(elementOrSelector);
2169  const gestureAbortController = new AbortController();
2170  const eventOptions = {
2171    passive: true,
2172    ...options,
2173    signal: gestureAbortController.signal
2174  };
2175  const cancel = () => gestureAbortController.abort();
2176  return [elements, eventOptions, cancel];
2177}
2178function filterEvents(callback) {
2179  return (event) => {
2180    if (event.pointerType === "touch" || isDragActive())
2181      return;
2182    callback(event);
2183  };
2184}
2185function hover(elementOrSelector, onHoverStart, options = {}) {
2186  const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);
2187  const onPointerEnter = filterEvents((enterEvent) => {
2188    const { target } = enterEvent;
2189    const onHoverEnd = onHoverStart(enterEvent);
2190    if (typeof onHoverEnd !== "function" || !target)
2191      return;
2192    const onPointerLeave = filterEvents((leaveEvent) => {
2193      onHoverEnd(leaveEvent);
2194      target.removeEventListener("pointerleave", onPointerLeave);
2195    });
2196    target.addEventListener("pointerleave", onPointerLeave, eventOptions);
2197  });
2198  elements.forEach((element) => {
2199    element.addEventListener("pointerenter", onPointerEnter, eventOptions);
2200  });
2201  return cancel;
2202}
2203var import_dist355 = __toESM(require_dist(), 1);
2204var import_dist356 = __toESM(require_dist2(), 1);
2205var import_dist357 = __toESM(require_dist3(), 1);
2206var import_dist340 = __toESM(require_dist(), 1);
2207var import_dist341 = __toESM(require_dist2(), 1);
2208var import_dist342 = __toESM(require_dist3(), 1);
2209var isNodeOrChild = (parent, child) => {
2210  if (!child) {
2211    return false;

2212  } else if (parent === child) {
2213    return true;
2214  } else {
2215    return isNodeOrChild(parent, child.parentElement);
2216  }
2217};
2218var import_dist343 = __toESM(require_dist(), 1);
2219var import_dist344 = __toESM(require_dist2(), 1);
2220var import_dist345 = __toESM(require_dist3(), 1);
2221var isPrimaryPointer = (event) => {
2222  if (event.pointerType === "mouse") {
2223    return typeof event.button !== "number" || event.button <= 0;
2224  } else {
2225    return event.isPrimary !== false;
2226  }
2227};
2228var import_dist346 = __toESM(require_dist(), 1);
2229var import_dist347 = __toESM(require_dist2(), 1);
2230var import_dist348 = __toESM(require_dist3(), 1);
2231var focusableElements = /* @__PURE__ */ new Set([
2232  "BUTTON",
2233  "INPUT",
2234  "SELECT",
2235  "TEXTAREA",
2236  "A"
2237]);
2238function isElementKeyboardAccessible(element) {
2239  return focusableElements.has(element.tagName) || element.tabIndex !== -1;
2240}
2241var import_dist352 = __toESM(require_dist(), 1);
2242var import_dist353 = __toESM(require_dist2(), 1);
2243var import_dist354 = __toESM(require_dist3(), 1);
2244var import_dist349 = __toESM(require_dist(), 1);
2245var import_dist350 = __toESM(require_dist2(), 1);
2246var import_dist351 = __toESM(require_dist3(), 1);
2247var isPressing = /* @__PURE__ */ new WeakSet();
2248function filterEvents2(callback) {
2249  return (event) => {
2250    if (event.key !== "Enter")
2251      return;
2252    callback(event);
2253  };
2254}
2255function firePointerEvent(target, type) {
2256  target.dispatchEvent(new PointerEvent("pointer" + type, { isPrimary: true, bubbles: true }));
2257}
2258var enableKeyboardPress = (focusEvent, eventOptions) => {
2259  const element = focusEvent.currentTarget;
2260  if (!element)
2261    return;
2262  const handleKeydown = filterEvents2(() => {
2263    if (isPressing.has(element))
2264      return;
2265    firePointerEvent(element, "down");
2266    const handleKeyup = filterEvents2(() => {
2267      firePointerEvent(element, "up");
2268    });
2269    const handleBlur = () => firePointerEvent(element, "cancel");
2270    element.addEventListener("keyup", handleKeyup, eventOptions);
2271    element.addEventListener("blur", handleBlur, eventOptions);
2272  });
2273  element.addEventListener("keydown", handleKeydown, eventOptions);
2274  element.addEventListener("blur", () => element.removeEventListener("keydown", handleKeydown), eventOptions);
2275};
2276function isValidPressEvent(event) {
2277  return isPrimaryPointer(event) && !isDragActive();
2278}
2279function press(elementOrSelector, onPressStart, options = {}) {
2280  const [elements, eventOptions, cancelEvents] = setupGesture(elementOrSelector, options);
2281  const startPress = (startEvent) => {
2282    const element = startEvent.currentTarget;
2283    if (!isValidPressEvent(startEvent) || isPressing.has(element))
2284      return;
2285    isPressing.add(element);
2286    const onPressEnd = onPressStart(startEvent);
2287    const onPointerEnd = (endEvent, success) => {
2288      window.removeEventListener("pointerup", onPointerUp);
2289      window.removeEventListener("pointercancel", onPointerCancel);
2290      if (!isValidPressEvent(endEvent) || !isPressing.has(element)) {
2291        return;
2292      }
2293      isPressing.delete(element);
2294      if (typeof onPressEnd === "function") {
2295        onPressEnd(endEvent, { success });
2296      }
2297    };
2298    const onPointerUp = (upEvent) => {
2299      onPointerEnd(upEvent, options.useGlobalTarget || isNodeOrChild(element, upEvent.target));
2300    };
2301    const onPointerCancel = (cancelEvent) => {
2302      onPointerEnd(cancelEvent, false);
2303    };
2304    window.addEventListener("pointerup", onPointerUp, eventOptions);
2305    window.addEventListener("pointercancel", onPointerCancel, eventOptions);
2306  };
2307  elements.forEach((element) => {
2308    if (!isElementKeyboardAccessible(element) && element.getAttribute("tabindex") === null) {
2309      element.tabIndex = 0;
2310    }
2311    const target = options.useGlobalTarget ? window : element;
2312    target.addEventListener("pointerdown", startPress, eventOptions);
2313    element.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions), eventOptions);
2314  });
2315  return cancelEvents;
2316}
2317var import_dist382 = __toESM(require_dist(), 1);
2318var import_dist383 = __toESM(require_dist2(), 1);
2319var import_dist384 = __toESM(require_dist3(), 1);
2320var import_dist379 = __toESM(require_dist(), 1);
2321var import_dist380 = __toESM(require_dist2(), 1);
2322var import_dist381 = __toESM(require_dist3(), 1);
2323var import_dist361 = __toESM(require_dist(), 1);
2324var import_dist362 = __toESM(require_dist2(), 1);
2325var import_dist363 = __toESM(require_dist3(), 1);
2326var import_dist358 = __toESM(require_dist(), 1);
2327var import_dist359 = __toESM(require_dist2(), 1);
2328var import_dist360 = __toESM(require_dist3(), 1);
2329var import_dist364 = __toESM(require_dist(), 1);
2330var import_dist365 = __toESM(require_dist2(), 1);
2331var import_dist366 = __toESM(require_dist3(), 1);
2332var import_dist367 = __toESM(require_dist(), 1);
2333var import_dist368 = __toESM(require_dist2(), 1);
2334var import_dist369 = __toESM(require_dist3(), 1);
2335var import_dist370 = __toESM(require_dist(), 1);
2336var import_dist371 = __toESM(require_dist2(), 1);
2337var import_dist372 = __toESM(require_dist3(), 1);
2338var import_dist373 = __toESM(require_dist(), 1);
2339var import_dist374 = __toESM(require_dist2(), 1);
2340var import_dist375 = __toESM(require_dist3(), 1);
2341var import_dist376 = __toESM(require_dist(), 1);
2342var import_dist377 = __toESM(require_dist2(), 1);
2343var import_dist378 = __toESM(require_dist3(), 1);
2344var import_dist385 = __toESM(require_dist(), 1);
2345var import_dist386 = __toESM(require_dist2(), 1);
2346var import_dist387 = __toESM(require_dist3(), 1);
2347function setDragLock(axis) {
2348  if (axis === "x" || axis === "y") {
2349    if (isDragging[axis]) {
2350      return null;
2351    } else {
2352      isDragging[axis] = true;
2353      return () => {
2354        isDragging[axis] = false;

2355      };
2356    }
2357  } else {
2358    if (isDragging.x || isDragging.y) {
2359      return null;
2360    } else {
2361      isDragging.x = isDragging.y = true;
2362      return () => {
2363        isDragging.x = isDragging.y = false;
2364      };
2365    }
2366  }
2367}
2368var import_dist391 = __toESM(require_dist(), 1);
2369var import_dist392 = __toESM(require_dist2(), 1);
2370var import_dist393 = __toESM(require_dist3(), 1);
2371var positionalKeys = /* @__PURE__ */ new Set([
2372  "width",
2373  "height",
2374  "top",
2375  "left",
2376  "right",
2377  "bottom",
2378  ...transformPropOrder
2379]);
2380var import_dist409 = __toESM(require_dist(), 1);
2381var import_dist410 = __toESM(require_dist2(), 1);
2382var import_dist411 = __toESM(require_dist3(), 1);
2383var import_dist406 = __toESM(require_dist(), 1);
2384var import_dist407 = __toESM(require_dist2(), 1);
2385var import_dist408 = __toESM(require_dist3(), 1);
2386var import_dist394 = __toESM(require_dist(), 1);
2387var import_dist395 = __toESM(require_dist2(), 1);
2388var import_dist396 = __toESM(require_dist3(), 1);
2389var now;
2390function clearTime() {
2391  now = void 0;
2392}
2393var time = {
2394  now: () => {
2395    if (now === void 0) {
2396      time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
2397    }
2398    return now;
2399  },
2400  set: (newTime) => {
2401    now = newTime;
2402    queueMicrotask(clearTime);
2403  }
2404};
2405var import_dist400 = __toESM(require_dist(), 1);
2406var import_dist401 = __toESM(require_dist2(), 1);
2407var import_dist402 = __toESM(require_dist3(), 1);
2408var import_dist397 = __toESM(require_dist(), 1);
2409var import_dist398 = __toESM(require_dist2(), 1);
2410var import_dist399 = __toESM(require_dist3(), 1);
2411function addUniqueItem(arr, item) {
2412  if (arr.indexOf(item) === -1)
2413    arr.push(item);
2414}
2415function removeItem(arr, item) {
2416  const index = arr.indexOf(item);
2417  if (index > -1)
2418    arr.splice(index, 1);
2419}
2420function moveItem([...arr], fromIndex, toIndex) {
2421  const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;
2422  if (startIndex >= 0 && startIndex < arr.length) {
2423    const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;
2424    const [item] = arr.splice(fromIndex, 1);
2425    arr.splice(endIndex, 0, item);
2426  }
2427  return arr;
2428}
2429var SubscriptionManager = class {
2430  constructor() {
2431    this.subscriptions = [];
2432  }
2433  add(handler) {
2434    addUniqueItem(this.subscriptions, handler);
2435    return () => removeItem(this.subscriptions, handler);
2436  }
2437  notify(a, b, c) {
2438    const numSubscriptions = this.subscriptions.length;
2439    if (!numSubscriptions)
2440      return;
2441    if (numSubscriptions === 1) {
2442      this.subscriptions[0](a, b, c);
2443    } else {
2444      for (let i = 0; i < numSubscriptions; i++) {
2445        const handler = this.subscriptions[i];
2446        handler && handler(a, b, c);
2447      }
2448    }
2449  }
2450  getSize() {
2451    return this.subscriptions.length;
2452  }
2453  clear() {
2454    this.subscriptions.length = 0;
2455  }
2456};
2457var import_dist403 = __toESM(require_dist(), 1);
2458var import_dist404 = __toESM(require_dist2(), 1);
2459var import_dist405 = __toESM(require_dist3(), 1);
2460function velocityPerSecond(velocity, frameDuration) {
2461  return frameDuration ? velocity * (1e3 / frameDuration) : 0;
2462}
2463var MAX_VELOCITY_DELTA = 30;
2464var isFloat = (value) => {
2465  return !isNaN(parseFloat(value));
2466};
2467var collectMotionValues = {
2468  current: void 0
2469};
2470var MotionValue = class {
2471  /**
2472   * @param init - The initiating value
2473   * @param config - Optional configuration options
2474   *
2475   * -  `transformer`: A function to transform incoming values with.
2476   *
2477   * @internal
2478   */
2479  constructor(init, options = {}) {
2480    this.version = "11.18.2";
2481    this.canTrackVelocity = null;
2482    this.events = {};
2483    this.updateAndNotify = (v, render = true) => {
2484      const currentTime = time.now();
2485      if (this.updatedAt !== currentTime) {
2486        this.setPrevFrameValue();
2487      }
2488      this.prev = this.current;
2489      this.setCurrent(v);
2490      if (this.current !== this.prev && this.events.change) {
2491        this.events.change.notify(this.current);
2492      }
2493      if (render && this.events.renderRequest) {
2494        this.events.renderRequest.notify(this.current);
2495      }
2496    };
2497    this.hasAnimated = false;
2498    this.setCurrent(init);
2499    this.owner = options.owner;
2500  }
2501  setCurrent(current) {
2502    this.current = current;
2503    this.updatedAt = time.now();
2504    if (this.canTrackVelocity === null && current !== void 0) {
2505      this.canTrackVelocity = isFloat(this.current);
2506    }
2507  }
2508  setPrevFrameValue(prevFrameValue = this.current) {
2509    this.prevFrameValue = prevFrameValue;
2510    this.prevUpdatedAt = this.updatedAt;
2511  }
2512  /**
2513   * Adds a function that will be notified when the `MotionValue` is updated.
2514   *
2515   * It returns a function that, when called, will cancel the subscription.
2516   *
2517   * When calling `onChange` inside a React component, it should be wrapped with the
2518   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
2519   * from the `useEffect` function to ensure you don't add duplicate subscribers..
2520   *
2521   * ```jsx
2522   * export const MyComponent = () => {
2523   *   const x = useMotionValue(0)
2524   *   const y = useMotionValue(0)
2525   *   const opacity = useMotionValue(1)
2526   *
2527   *   useEffect(() => {
2528   *     function updateOpacity() {
2529   *       const maxXY = Math.max(x.get(), y.get())
2530   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
2531   *       opacity.set(newOpacity)
2532   *     }
2533   *
2534   *     const unsubscribeX = x.on("change", updateOpacity)
2535   *     const unsubscribeY = y.on("change", updateOpacity)
2536   *
2537   *     return () => {
2538   *       unsubscribeX()
2539   *       unsubscribeY()
2540   *     }
2541   *   }, [])
2542   *
2543   *   return <motion.div style={{ x }} />
2544   * }
2545   * ```
2546   *
2547   * @param subscriber - A function that receives the latest value.
2548   * @returns A function that, when called, will cancel this subscription.
2549   *
2550   * @deprecated
2551   */
2552  onChange(subscription) {
2553    if (true) {
2554      warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on("change", callback).`);
2555    }
2556    return this.on("change", subscription);
2557  }
2558  on(eventName, callback) {
2559    if (!this.events[eventName]) {
2560      this.events[eventName] = new SubscriptionManager();
2561    }
2562    const unsubscribe = this.events[eventName].add(callback);
2563    if (eventName === "change") {
2564      return () => {
2565        unsubscribe();
2566        frame.read(() => {
2567          if (!this.events.change.getSize()) {
2568            this.stop();
2569          }
2570        });
2571      };
2572    }
2573    return unsubscribe;
2574  }
2575  clearListeners() {
2576    for (const eventManagers in this.events) {
2577      this.events[eventManagers].clear();
2578    }
2579  }
2580  /**
2581   * Attaches a passive effect to the `MotionValue`.
2582   *
2583   * @internal
2584   */
2585  attach(passiveEffect, stopPassiveEffect) {
2586    this.passiveEffect = passiveEffect;
2587    this.stopPassiveEffect = stopPassiveEffect;
2588  }
2589  /**
2590   * Sets the state of the `MotionValue`.
2591   *
2592   * @remarks
2593   *
2594   * ```jsx
2595   * const x = useMotionValue(0)
2596   * x.set(10)
2597   * ```
2598   *
2599   * @param latest - Latest value to set.
2600   * @param render - Whether to notify render subscribers. Defaults to `true`
2601   *
2602   * @public
2603   */
2604  set(v, render = true) {
2605    if (!render || !this.passiveEffect) {
2606      this.updateAndNotify(v, render);
2607    } else {
2608      this.passiveEffect(v, this.updateAndNotify);
2609    }
2610  }
2611  setWithVelocity(prev, current, delta) {
2612    this.set(current);
2613    this.prev = void 0;
2614    this.prevFrameValue = prev;
2615    this.prevUpdatedAt = this.updatedAt - delta;
2616  }
2617  /**
2618   * Set the state of the `MotionValue`, stopping any active animations,
2619   * effects, and resets velocity to `0`.
2620   */
2621  jump(v, endAnimation = true) {
2622    this.updateAndNotify(v);
2623    this.prev = v;
2624    this.prevUpdatedAt = this.prevFrameValue = void 0;
2625    endAnimation && this.stop();
2626    if (this.stopPassiveEffect)
2627      this.stopPassiveEffect();
2628  }
2629  /**
2630   * Returns the latest state of `MotionValue`
2631   *
2632   * @returns - The latest state of `MotionValue`
2633   *
2634   * @public
2635   */
2636  get() {
2637    if (collectMotionValues.current) {
2638      collectMotionValues.current.push(this);
2639    }
2640    return this.current;
2641  }
2642  /**
2643   * @public
2644   */
2645  getPrevious() {
2646    return this.prev;
2647  }
2648  /**
2649   * Returns the latest velocity of `MotionValue`
2650   *
2651   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
2652   *
2653   * @public
2654   */
2655  getVelocity() {
2656    const currentTime = time.now();
2657    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {
2658      return 0;
2659    }
2660    const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);
2661    return velocityPerSecond(parseFloat(this.current) - parseFloat(this.prevFrameValue), delta);
2662  }
2663  /**
2664   * Registers a new animation to control this `MotionValue`. Only one
2665   * animation can drive a `MotionValue` at one time.
2666   *
2667   * ```jsx
2668   * value.start()
2669   * ```
2670   *
2671   * @param animation - A function that starts the provided animation
2672   *
2673   * @internal
2674   */
2675  start(startAnimation) {
2676    this.stop();
2677    return new Promise((resolve) => {
2678      this.hasAnimated = true;
2679      this.animation = startAnimation(resolve);
2680      if (this.events.animationStart) {
2681        this.events.animationStart.notify();
2682      }
2683    }).then(() => {
2684      if (this.events.animationComplete) {
2685        this.events.animationComplete.notify();
2686      }
2687      this.clearAnimation();
2688    });
2689  }
2690  /**
2691   * Stop the currently active animation.
2692   *
2693   * @public
2694   */
2695  stop() {
2696    if (this.animation) {
2697      this.animation.stop();
2698      if (this.events.animationCancel) {
2699        this.events.animationCancel.notify();
2700      }
2701    }
2702    this.clearAnimation();
2703  }
2704  /**
2705   * Returns `true` if this value is currently animating.
2706   *
2707   * @public
2708   */
2709  isAnimating() {
2710    return !!this.animation;
2711  }
2712  clearAnimation() {
2713    delete this.animation;
2714  }
2715  /**
2716   * Destroy and clean up subscribers to this `MotionValue`.
2717   *
2718   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
2719   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
2720   * created a `MotionValue` via the `motionValue` function.
2721   *
2722   * @public
2723   */
2724  destroy() {
2725    this.clearListeners();
2726    this.stop();
2727    if (this.stopPassiveEffect) {
2728      this.stopPassiveEffect();
2729    }
2730  }
2731};
2732function motionValue(init, options) {
2733  return new MotionValue(init, options);
2734}
2735function setMotionValue(visualElement, key, value) {
2736  if (visualElement.hasValue(key)) {
2737    visualElement.getValue(key).set(value);
2738  } else {
2739    visualElement.addValue(key, motionValue(value));
2740  }
2741}
2742function setTarget(visualElement, definition) {
2743  const resolved = resolveVariant(visualElement, definition);
2744  let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
2745  target = { ...target, ...transitionEnd };
2746  for (const key in target) {
2747    const value = resolveFinalValueInKeyframes(target[key]);
2748    setMotionValue(visualElement, key, value);
2749  }
2750}
2751var import_dist415 = __toESM(require_dist(), 1);
2752var import_dist416 = __toESM(require_dist2(), 1);
2753var import_dist417 = __toESM(require_dist3(), 1);
2754var import_dist412 = __toESM(require_dist(), 1);
2755var import_dist413 = __toESM(require_dist2(), 1);
2756var import_dist414 = __toESM(require_dist3(), 1);
2757function isWillChangeMotionValue(value) {
2758  return Boolean(isMotionValue(value) && value.add);
2759}
2760function addValueToWillChange(visualElement, key) {
2761  const willChange = visualElement.getValue("willChange");
2762  if (isWillChangeMotionValue(willChange)) {
2763    return willChange.add(key);
2764  }
2765}
2766var import_dist418 = __toESM(require_dist(), 1);
2767var import_dist419 = __toESM(require_dist2(), 1);
2768var import_dist420 = __toESM(require_dist3(), 1);
2769function getOptimisedAppearId(visualElement) {
2770  return visualElement.props[optimizedAppearDataAttribute];
2771}
2772var import_dist616 = __toESM(require_dist(), 1);
2773var import_dist617 = __toESM(require_dist2(), 1);
2774var import_dist618 = __toESM(require_dist3(), 1);
2775var import_dist421 = __toESM(require_dist(), 1);
2776var import_dist422 = __toESM(require_dist2(), 1);
2777var import_dist423 = __toESM(require_dist3(), 1);
2778var instantAnimationState = {
2779  current: false
2780};
2781var import_dist607 = __toESM(require_dist(), 1);
2782var import_dist608 = __toESM(require_dist2(), 1);
2783var import_dist609 = __toESM(require_dist3(), 1);
2784var import_dist436 = __toESM(require_dist(), 1);
2785var import_dist437 = __toESM(require_dist2(), 1);
2786var import_dist438 = __toESM(require_dist3(), 1);
2787var import_dist433 = __toESM(require_dist(), 1);
2788var import_dist434 = __toESM(require_dist2(), 1);
2789var import_dist435 = __toESM(require_dist3(), 1);
2790var import_dist424 = __toESM(require_dist(), 1);
2791var import_dist425 = __toESM(require_dist2(), 1);
2792var import_dist426 = __toESM(require_dist3(), 1);
2793var calcBezier = (t, a1, a2) => (((1 - 3 * a2 + 3 * a1) * t + (3 * a2 - 6 * a1)) * t + 3 * a1) * t;
2794var subdivisionPrecision = 1e-7;
2795var subdivisionMaxIterations = 12;
2796function binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {
2797  let currentX;
2798  let currentT;
2799  let i = 0;
2800  do {
2801    currentT = lowerBound + (upperBound - lowerBound) / 2;
2802    currentX = calcBezier(currentT, mX1, mX2) - x;
2803    if (currentX > 0) {
2804      upperBound = currentT;
2805    } else {
2806      lowerBound = currentT;
2807    }
2808  } while (Math.abs(currentX) > subdivisionPrecision && ++i < subdivisionMaxIterations);
2809  return currentT;
2810}
2811function cubicBezier(mX1, mY1, mX2, mY2) {
2812  if (mX1 === mY1 && mX2 === mY2)
2813    return noop;
2814  const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
2815  return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);
2816}
2817var import_dist427 = __toESM(require_dist(), 1);
2818var import_dist428 = __toESM(require_dist2(), 1);
2819var import_dist429 = __toESM(require_dist3(), 1);
2820var mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;
2821var import_dist430 = __toESM(require_dist(), 1);
2822var import_dist431 = __toESM(require_dist2(), 1);
2823var import_dist432 = __toESM(require_dist3(), 1);
2824var reverseEasing = (easing) => (p) => 1 - easing(1 - p);
2825var backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);
2826var backIn = reverseEasing(backOut);
2827var backInOut = mirrorEasing(backIn);
2828var anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));
2829var import_dist439 = __toESM(require_dist(), 1);
2830var import_dist440 = __toESM(require_dist2(), 1);
2831var import_dist441 = __toESM(require_dist3(), 1);
2832var circIn = (p) => 1 - Math.sin(Math.acos(p));
2833var circOut = reverseEasing(circIn);
2834var circInOut = mirrorEasing(circIn);
2835var import_dist514 = __toESM(require_dist(), 1);
2836var import_dist515 = __toESM(require_dist2(), 1);
2837var import_dist516 = __toESM(require_dist3(), 1);
2838var import_dist445 = __toESM(require_dist(), 1);
2839var import_dist446 = __toESM(require_dist2(), 1);
2840var import_dist447 = __toESM(require_dist3(), 1);
2841var import_dist442 = __toESM(require_dist(), 1);
2842var import_dist443 = __toESM(require_dist2(), 1);
2843var import_dist444 = __toESM(require_dist3(), 1);
2844var isZeroValueString = (v) => /^0[^.\s]+$/u.test(v);
2845function isNone(value) {
2846  if (typeof value === "number") {
2847    return value === 0;
2848  } else if (value !== null) {
2849    return value === "none" || value === "0" || isZeroValueString(value);
2850  } else {
2851    return true;
2852  }
2853}
2854var import_dist490 = __toESM(require_dist(), 1);
2855var import_dist491 = __toESM(require_dist2(), 1);
2856var import_dist492 = __toESM(require_dist3(), 1);
2857var import_dist478 = __toESM(require_dist(), 1);
2858var import_dist479 = __toESM(require_dist2(), 1);
2859var import_dist480 = __toESM(require_dist3(), 1);
2860var import_dist472 = __toESM(require_dist(), 1);
2861var import_dist473 = __toESM(require_dist2(), 1);
2862var import_dist474 = __toESM(require_dist3(), 1);
2863var import_dist466 = __toESM(require_dist(), 1);
2864var import_dist467 = __toESM(require_dist2(), 1);
2865var import_dist468 = __toESM(require_dist3(), 1);
2866var import_dist463 = __toESM(require_dist(), 1);
2867var import_dist464 = __toESM(require_dist2(), 1);
2868var import_dist465 = __toESM(require_dist3(), 1);
2869var import_dist448 = __toESM(require_dist(), 1);
2870var import_dist449 = __toESM(require_dist2(), 1);
2871var import_dist450 = __toESM(require_dist3(), 1);
2872var sanitize = (v) => Math.round(v * 1e5) / 1e5;
2873var import_dist460 = __toESM(require_dist(), 1);
2874var import_dist461 = __toESM(require_dist2(), 1);
2875var import_dist462 = __toESM(require_dist3(), 1);
2876var import_dist451 = __toESM(require_dist(), 1);
2877var import_dist452 = __toESM(require_dist2(), 1);
2878var import_dist453 = __toESM(require_dist3(), 1);
2879var floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
2880var import_dist454 = __toESM(require_dist(), 1);
2881var import_dist455 = __toESM(require_dist2(), 1);
2882var import_dist456 = __toESM(require_dist3(), 1);
2883function isNullish(v) {
2884  return v == null;
2885}
2886var import_dist457 = __toESM(require_dist(), 1);
2887var import_dist458 = __toESM(require_dist2(), 1);
2888var import_dist459 = __toESM(require_dist3(), 1);
2889var singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu;
2890var isColorString = (type, testProp) => (v) => {
2891  return Boolean(typeof v === "string" && singleColorRegex.test(v) && v.startsWith(type) || testProp && !isNullish(v) && Object.prototype.hasOwnProperty.call(v, testProp));
2892};
2893var splitColor = (aName, bName, cName) => (v) => {
2894  if (typeof v !== "string")
2895    return v;
2896  const [a, b, c, alpha2] = v.match(floatRegex);
2897  return {
2898    [aName]: parseFloat(a),
2899    [bName]: parseFloat(b),
2900    [cName]: parseFloat(c),
2901    alpha: alpha2 !== void 0 ? parseFloat(alpha2) : 1
2902  };
2903};
2904var clampRgbUnit = (v) => clamp(0, 255, v);
2905var rgbUnit = {
2906  ...number,
2907  transform: (v) => Math.round(clampRgbUnit(v))
2908};
2909var rgba = {
2910  test: isColorString("rgb", "red"),
2911  parse: splitColor("red", "green", "blue"),
2912  transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => "rgba(" + rgbUnit.transform(red) + ", " + rgbUnit.transform(green) + ", " + rgbUnit.transform(blue) + ", " + sanitize(alpha.transform(alpha$1)) + ")"
2913};
2914function parseHex(v) {
2915  let r = "";
2916  let g = "";
2917  let b = "";
2918  let a = "";
2919  if (v.length > 5) {
2920    r = v.substring(1, 3);
2921    g = v.substring(3, 5);
2922    b = v.substring(5, 7);
2923    a = v.substring(7, 9);
2924  } else {
2925    r = v.substring(1, 2);
2926    g = v.substring(2, 3);
2927    b = v.substring(3, 4);
2928    a = v.substring(4, 5);
2929    r += r;
2930    g += g;
2931    b += b;
2932    a += a;
2933  }
2934  return {
2935    red: parseInt(r, 16),
2936    green: parseInt(g, 16),
2937    blue: parseInt(b, 16),
2938    alpha: a ? parseInt(a, 16) / 255 : 1
2939  };
2940}
2941var hex = {
2942  test: isColorString("#"),
2943  parse: parseHex,
2944  transform: rgba.transform
2945};
2946var import_dist469 = __toESM(require_dist(), 1);
2947var import_dist470 = __toESM(require_dist2(), 1);
2948var import_dist471 = __toESM(require_dist3(), 1);
2949var hsla = {
2950  test: isColorString("hsl", "hue"),
2951  parse: splitColor("hue", "saturation", "lightness"),
2952  transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {
2953    return "hsla(" + Math.round(hue) + ", " + percent.transform(sanitize(saturation)) + ", " + percent.transform(sanitize(lightness)) + ", " + sanitize(alpha.transform(alpha$1)) + ")";
2954  }
2955};
2956var color = {
2957  test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),
2958  parse: (v) => {
2959    if (rgba.test(v)) {
2960      return rgba.parse(v);
2961    } else if (hsla.test(v)) {
2962      return hsla.parse(v);
2963    } else {
2964      return hex.parse(v);
2965    }
2966  },
2967  transform: (v) => {
2968    return typeof v === "string" ? v : v.hasOwnProperty("red") ? rgba.transform(v) : hsla.transform(v);
2969  }
2970};
2971var import_dist475 = __toESM(require_dist(), 1);
2972var import_dist476 = __toESM(require_dist2(), 1);
2973var import_dist477 = __toESM(require_dist3(), 1);
2974var colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
2975function test(v) {
2976  var _a, _b;
2977  return isNaN(v) && typeof v === "string" && (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) + (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) > 0;
2978}
2979var NUMBER_TOKEN = "number";
2980var COLOR_TOKEN = "color";
2981var VAR_TOKEN = "var";
2982var VAR_FUNCTION_TOKEN = "var(";
2983var SPLIT_TOKEN = "${}";
2984var complexRegex = /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;
2985function analyseComplexValue(value) {
2986  const originalValue = value.toString();
2987  const values = [];
2988  const indexes = {
2989    color: [],
2990    number: [],
2991    var: []
2992  };
2993  const types = [];
2994  let i = 0;
2995  const tokenised = originalValue.replace(complexRegex, (parsedValue) => {
2996    if (color.test(parsedValue)) {
2997      indexes.color.push(i);
2998      types.push(COLOR_TOKEN);
2999      values.push(color.parse(parsedValue));
3000    } else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
3001      indexes.var.push(i);
3002      types.push(VAR_TOKEN);
3003      values.push(parsedValue);
3004    } else {
3005      indexes.number.push(i);
3006      types.push(NUMBER_TOKEN);
3007      values.push(parseFloat(parsedValue));
3008    }
3009    ++i;
3010    return SPLIT_TOKEN;
3011  });
3012  const split = tokenised.split(SPLIT_TOKEN);
3013  return { values, split, indexes, types };
3014}
3015function parseComplexValue(v) {
3016  return analyseComplexValue(v).values;
3017}
3018function createTransformer(source) {
3019  const { split, types } = analyseComplexValue(source);
3020  const numSections = split.length;
3021  return (v) => {
3022    let output = "";
3023    for (let i = 0; i < numSections; i++) {
3024      output += split[i];
3025      if (v[i] !== void 0) {
3026        const type = types[i];
3027        if (type === NUMBER_TOKEN) {
3028          output += sanitize(v[i]);
3029        } else if (type === COLOR_TOKEN) {
3030          output += color.transform(v[i]);
3031        } else {
3032          output += v[i];
3033        }
3034      }
3035    }
3036    return output;
3037  };
3038}
3039var convertNumbersToZero = (v) => typeof v === "number" ? 0 : v;
3040function getAnimatableNone(v) {
3041  const parsed = parseComplexValue(v);
3042  const transformer = createTransformer(v);
3043  return transformer(parsed.map(convertNumbersToZero));
3044}
3045var complex = {
3046  test,
3047  parse: parseComplexValue,
3048  createTransformer,
3049  getAnimatableNone
3050};
3051var import_dist487 = __toESM(require_dist(), 1);
3052var import_dist488 = __toESM(require_dist2(), 1);
3053var import_dist489 = __toESM(require_dist3(), 1);
3054var import_dist481 = __toESM(require_dist(), 1);
3055var import_dist482 = __toESM(require_dist2(), 1);
3056var import_dist483 = __toESM(require_dist3(), 1);
3057var maxDefaults = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
3058function applyDefaultFilter(v) {
3059  const [name, value] = v.slice(0, -1).split("(");
3060  if (name === "drop-shadow")
3061    return v;
3062  const [number2] = value.match(floatRegex) || [];
3063  if (!number2)
3064    return v;
3065  const unit = value.replace(number2, "");
3066  let defaultValue = maxDefaults.has(name) ? 1 : 0;
3067  if (number2 !== value)
3068    defaultValue *= 100;
3069  return name + "(" + defaultValue + unit + ")";
3070}
3071var functionRegex = /\b([a-z-]*)\(.*?\)/gu;
3072var filter = {
3073  ...complex,
3074  getAnimatableNone: (v) => {
3075    const functions = v.match(functionRegex);
3076    return functions ? functions.map(applyDefaultFilter).join(" ") : v;
3077  }
3078};
3079var import_dist484 = __toESM(require_dist(), 1);
3080var import_dist485 = __toESM(require_dist2(), 1);
3081var import_dist486 = __toESM(require_dist3(), 1);
3082var defaultValueTypes = {
3083  ...numberValueTypes,
3084  // Color props
3085  color,
3086  backgroundColor: color,
3087  outlineColor: color,
3088  fill: color,
3089  stroke: color,
3090  // Border props
3091  borderColor: color,
3092  borderTopColor: color,
3093  borderRightColor: color,
3094  borderBottomColor: color,
3095  borderLeftColor: color,
3096  filter,
3097  WebkitFilter: filter
3098};
3099var getDefaultValueType = (key) => defaultValueTypes[key];
3100function getAnimatableNone2(key, value) {
3101  let defaultValueType = getDefaultValueType(key);
3102  if (defaultValueType !== filter)
3103    defaultValueType = complex;
3104  return defaultValueType.getAnimatableNone ? defaultValueType.getAnimatableNone(value) : void 0;
3105}
3106var invalidTemplates = /* @__PURE__ */ new Set(["auto", "none", "0"]);
3107function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
3108  let i = 0;
3109  let animatableTemplate = void 0;
3110  while (i < unresolvedKeyframes.length && !animatableTemplate) {