Mission Control Dashboard - Initial implementation

node_modules/framer-motion/dist/es/value/scroll/use-element-scroll.mjs

@@ -0,0 +1,15 @@
+import { warnOnce } from 'motion-utils';
+import { useScroll } from '../use-scroll.mjs';
+
+/**
+ * @deprecated useElementScroll is deprecated. Convert to useScroll({ container: ref })
+ */
+function useElementScroll(ref) {
+    if (process.env.NODE_ENV === "development") {
+        warnOnce(false, "useElementScroll is deprecated. Convert to useScroll({ container: ref }).");
+    }
+    return useScroll({ container: ref });
+}
+
+export { useElementScroll };
+//# sourceMappingURL=use-element-scroll.mjs.map

node_modules/framer-motion/dist/es/value/scroll/use-element-scroll.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-element-scroll.mjs","sources":["../../../../src/value/scroll/use-element-scroll.ts"],"sourcesContent":["import { warnOnce } from \"motion-utils\"\nimport { RefObject } from \"react\"\nimport { useScroll } from \"../use-scroll\"\n\n/**\n * @deprecated useElementScroll is deprecated. Convert to useScroll({ container: ref })\n */\nexport function useElementScroll(ref: RefObject<HTMLElement | null>) {\n    if (process.env.NODE_ENV === \"development\") {\n        warnOnce(\n            false,\n            \"useElementScroll is deprecated. Convert to useScroll({ container: ref }).\"\n        )\n    }\n\n    return useScroll({ container: ref })\n}\n"],"names":[],"mappings":";;;AAIA;;AAEG;AACG,SAAU,gBAAgB,CAAC,GAAkC,EAAA;IAC/D,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,EAAE;AACxC,QAAA,QAAQ,CACJ,KAAK,EACL,2EAA2E,CAC9E;IACL;IAEA,OAAO,SAAS,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AACxC;;;;"}

node_modules/framer-motion/dist/es/value/scroll/use-viewport-scroll.mjs

@@ -0,0 +1,15 @@
+import { warnOnce } from 'motion-utils';
+import { useScroll } from '../use-scroll.mjs';
+
+/**
+ * @deprecated useViewportScroll is deprecated. Convert to useScroll()
+ */
+function useViewportScroll() {
+    if (process.env.NODE_ENV !== "production") {
+        warnOnce(false, "useViewportScroll is deprecated. Convert to useScroll().");
+    }
+    return useScroll();
+}
+
+export { useViewportScroll };
+//# sourceMappingURL=use-viewport-scroll.mjs.map

node_modules/framer-motion/dist/es/value/scroll/use-viewport-scroll.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-viewport-scroll.mjs","sources":["../../../../src/value/scroll/use-viewport-scroll.ts"],"sourcesContent":["import { warnOnce } from \"motion-utils\"\nimport { useScroll } from \"../use-scroll\"\n\n/**\n * @deprecated useViewportScroll is deprecated. Convert to useScroll()\n */\nexport function useViewportScroll() {\n    if (process.env.NODE_ENV !== \"production\") {\n        warnOnce(\n            false,\n            \"useViewportScroll is deprecated. Convert to useScroll().\"\n        )\n    }\n    return useScroll()\n}\n"],"names":[],"mappings":";;;AAGA;;AAEG;SACa,iBAAiB,GAAA;IAC7B,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,EAAE;AACvC,QAAA,QAAQ,CACJ,KAAK,EACL,0DAA0D,CAC7D;IACL;IACA,OAAO,SAAS,EAAE;AACtB;;;;"}

node_modules/framer-motion/dist/es/value/use-combine-values.mjs

@@ -0,0 +1,39 @@
+"use client";
+import { cancelFrame, frame } from 'motion-dom';
+import { useIsomorphicLayoutEffect } from '../utils/use-isomorphic-effect.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+
+function useCombineMotionValues(values, combineValues) {
+    /**
+     * Initialise the returned motion value. This remains the same between renders.
+     */
+    const value = useMotionValue(combineValues());
+    /**
+     * Create a function that will update the template motion value with the latest values.
+     * This is pre-bound so whenever a motion value updates it can schedule its
+     * execution in Framesync. If it's already been scheduled it won't be fired twice
+     * in a single frame.
+     */
+    const updateValue = () => value.set(combineValues());
+    /**
+     * Synchronously update the motion value with the latest values during the render.
+     * This ensures that within a React render, the styles applied to the DOM are up-to-date.
+     */
+    updateValue();
+    /**
+     * Subscribe to all motion values found within the template. Whenever any of them change,
+     * schedule an update.
+     */
+    useIsomorphicLayoutEffect(() => {
+        const scheduleUpdate = () => frame.preRender(updateValue, false, true);
+        const subscriptions = values.map((v) => v.on("change", scheduleUpdate));
+        return () => {
+            subscriptions.forEach((unsubscribe) => unsubscribe());
+            cancelFrame(updateValue);
+        };
+    });
+    return value;
+}
+
+export { useCombineMotionValues };
+//# sourceMappingURL=use-combine-values.mjs.map

node_modules/framer-motion/dist/es/value/use-combine-values.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-combine-values.mjs","sources":["../../../src/value/use-combine-values.ts"],"sourcesContent":["\"use client\"\n\nimport { cancelFrame, frame, MotionValue } from \"motion-dom\"\nimport { useIsomorphicLayoutEffect } from \"../utils/use-isomorphic-effect\"\nimport { useMotionValue } from \"./use-motion-value\"\n\nexport function useCombineMotionValues<R>(\n    values: MotionValue[],\n    combineValues: () => R\n) {\n    /**\n     * Initialise the returned motion value. This remains the same between renders.\n     */\n    const value = useMotionValue(combineValues())\n\n    /**\n     * Create a function that will update the template motion value with the latest values.\n     * This is pre-bound so whenever a motion value updates it can schedule its\n     * execution in Framesync. If it's already been scheduled it won't be fired twice\n     * in a single frame.\n     */\n    const updateValue = () => value.set(combineValues())\n\n    /**\n     * Synchronously update the motion value with the latest values during the render.\n     * This ensures that within a React render, the styles applied to the DOM are up-to-date.\n     */\n    updateValue()\n\n    /**\n     * Subscribe to all motion values found within the template. Whenever any of them change,\n     * schedule an update.\n     */\n    useIsomorphicLayoutEffect(() => {\n        const scheduleUpdate = () => frame.preRender(updateValue, false, true)\n        const subscriptions = values.map((v) => v.on(\"change\", scheduleUpdate))\n\n        return () => {\n            subscriptions.forEach((unsubscribe) => unsubscribe())\n            cancelFrame(updateValue)\n        }\n    })\n\n    return value\n}\n"],"names":[],"mappings":";;;;;AAMM;AAIF;;AAEG;AACH;AAEA;;;;;AAKG;AACH;AAEA;;;AAGG;AACH;AAEA;;;AAGG;;AAEC;;AAGA;;;AAGA;AACJ;AAEA;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-computed.mjs

@@ -0,0 +1,21 @@
+"use client";
+import { collectMotionValues } from 'motion-dom';
+import { useCombineMotionValues } from './use-combine-values.mjs';
+
+function useComputed(compute) {
+    /**
+     * Open session of collectMotionValues. Any MotionValue that calls get()
+     * will be saved into this array.
+     */
+    collectMotionValues.current = [];
+    compute();
+    const value = useCombineMotionValues(collectMotionValues.current, compute);
+    /**
+     * Synchronously close session of collectMotionValues.
+     */
+    collectMotionValues.current = undefined;
+    return value;
+}
+
+export { useComputed };
+//# sourceMappingURL=use-computed.mjs.map

node_modules/framer-motion/dist/es/value/use-computed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-computed.mjs","sources":["../../../src/value/use-computed.ts"],"sourcesContent":["\"use client\"\n\nimport { collectMotionValues, type MotionValue } from \"motion-dom\"\nimport { useCombineMotionValues } from \"./use-combine-values\"\n\nexport function useComputed<O>(compute: () => O): MotionValue<O> {\n    /**\n     * Open session of collectMotionValues. Any MotionValue that calls get()\n     * will be saved into this array.\n     */\n    collectMotionValues.current = []\n\n    compute()\n\n    const value = useCombineMotionValues(collectMotionValues.current, compute)\n\n    /**\n     * Synchronously close session of collectMotionValues.\n     */\n    collectMotionValues.current = undefined\n\n    return value\n}\n"],"names":[],"mappings":";;;;AAKM;AACF;;;AAGG;AACH;AAEA;;AAIA;;AAEG;AACH;AAEA;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-follow-value.mjs

@@ -0,0 +1,23 @@
+"use client";
+import { attachFollow, isMotionValue } from 'motion-dom';
+import { useContext, useInsertionEffect } from 'react';
+import { MotionConfigContext } from '../context/MotionConfigContext.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+import { useTransform } from './use-transform.mjs';
+
+function useFollowValue(source, options = {}) {
+    const { isStatic } = useContext(MotionConfigContext);
+    const getFromSource = () => (isMotionValue(source) ? source.get() : source);
+    // isStatic will never change, allowing early hooks return
+    if (isStatic) {
+        return useTransform(getFromSource);
+    }
+    const value = useMotionValue(getFromSource());
+    useInsertionEffect(() => {
+        return attachFollow(value, source, options);
+    }, [value, JSON.stringify(options)]);
+    return value;
+}
+
+export { useFollowValue };
+//# sourceMappingURL=use-follow-value.mjs.map

node_modules/framer-motion/dist/es/value/use-follow-value.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-follow-value.mjs","sources":["../../../src/value/use-follow-value.ts"],"sourcesContent":["\"use client\"\n\nimport {\n    AnyResolvedKeyframe,\n    attachFollow,\n    FollowValueOptions,\n    isMotionValue,\n    MotionValue,\n} from \"motion-dom\"\nimport { useContext, useInsertionEffect } from \"react\"\nimport { MotionConfigContext } from \"../context/MotionConfigContext\"\nimport { useMotionValue } from \"./use-motion-value\"\nimport { useTransform } from \"./use-transform\"\n\n/**\n * Creates a `MotionValue` that, when `set`, will use the specified animation transition to animate to its new state.\n *\n * Unlike `useSpring` which is limited to spring animations, `useFollowValue` accepts any motion transition\n * including spring, tween, inertia, and keyframes.\n *\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\n * to another `MotionValue`.\n *\n * @remarks\n *\n * ```jsx\n * // Spring animation (default)\n * const x = useFollowValue(0, { stiffness: 300 })\n *\n * // Tween animation\n * const y = useFollowValue(0, { type: \"tween\", duration: 0.5, ease: \"easeOut\" })\n *\n * // Track another MotionValue with spring\n * const source = useMotionValue(0)\n * const z = useFollowValue(source, { type: \"spring\", damping: 10 })\n *\n * // Inertia animation\n * const w = useFollowValue(0, { type: \"inertia\", velocity: 100 })\n * ```\n *\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will animate towards that value using the specified transition.\n * @param options - Animation transition options. Supports all transition types: spring, tween, inertia, keyframes.\n * @returns `MotionValue`\n *\n * @public\n */\nexport function useFollowValue(\n    source: MotionValue<string>,\n    options?: FollowValueOptions\n): MotionValue<string>\nexport function useFollowValue(\n    source: string,\n    options?: FollowValueOptions\n): MotionValue<string>\nexport function useFollowValue(\n    source: MotionValue<number>,\n    options?: FollowValueOptions\n): MotionValue<number>\nexport function useFollowValue(\n    source: number,\n    options?: FollowValueOptions\n): MotionValue<number>\nexport function useFollowValue(\n    source: MotionValue<string> | MotionValue<number> | AnyResolvedKeyframe,\n    options: FollowValueOptions = {}\n) {\n    const { isStatic } = useContext(MotionConfigContext)\n    const getFromSource = () => (isMotionValue(source) ? source.get() : source)\n\n    // isStatic will never change, allowing early hooks return\n    if (isStatic) {\n        return useTransform(getFromSource)\n    }\n\n    const value = useMotionValue(getFromSource())\n\n    useInsertionEffect(() => {\n        return attachFollow(value, source, options)\n    }, [value, JSON.stringify(options)])\n\n    return value\n}\n"],"names":[],"mappings":";;;;;;;;;;;;AAuEQ;;AAGJ;;;AAIA;AAEA;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-inverted-scale.mjs

@@ -0,0 +1,54 @@
+"use client";
+import { invariant, warning } from 'motion-utils';
+import { useContext } from 'react';
+import { MotionContext } from '../context/MotionContext/index.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+import { useTransform } from './use-transform.mjs';
+
+// Keep things reasonable and avoid scale: Infinity. In practise we might need
+// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]
+// to simply hide content at unreasonable scales.
+const maxScale = 100000;
+const invertScale = (scale) => scale > 0.001 ? 1 / scale : maxScale;
+let hasWarned = false;
+/**
+ * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse
+ * of their respective parent scales.
+ *
+ * This is useful for undoing the distortion of content when scaling a parent component.
+ *
+ * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.
+ * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output
+ * of those instead.
+ *
+ * ```jsx
+ * const MyComponent = () => {
+ *   const { scaleX, scaleY } = useInvertedScale()
+ *   return <motion.div style={{ scaleX, scaleY }} />
+ * }
+ * ```
+ *
+ * @deprecated
+ */
+function useInvertedScale(scale) {
+    let parentScaleX = useMotionValue(1);
+    let parentScaleY = useMotionValue(1);
+    const { visualElement } = useContext(MotionContext);
+    invariant(!!(scale || visualElement), "If no scale values are provided, useInvertedScale must be used within a child of another motion component.");
+    warning(hasWarned, "useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.");
+    hasWarned = true;
+    if (scale) {
+        parentScaleX = scale.scaleX || parentScaleX;
+        parentScaleY = scale.scaleY || parentScaleY;
+    }
+    else if (visualElement) {
+        parentScaleX = visualElement.getValue("scaleX", 1);
+        parentScaleY = visualElement.getValue("scaleY", 1);
+    }
+    const scaleX = useTransform(parentScaleX, invertScale);
+    const scaleY = useTransform(parentScaleY, invertScale);
+    return { scaleX, scaleY };
+}
+
+export { invertScale, useInvertedScale };
+//# sourceMappingURL=use-inverted-scale.mjs.map

node_modules/framer-motion/dist/es/value/use-inverted-scale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-inverted-scale.mjs","sources":["../../../src/value/use-inverted-scale.ts"],"sourcesContent":["\"use client\"\n\nimport { MotionValue } from \"motion-dom\"\nimport { invariant, warning } from \"motion-utils\"\nimport { useContext } from \"react\"\nimport { MotionContext } from \"../context/MotionContext\"\nimport { useMotionValue } from \"./use-motion-value\"\nimport { useTransform } from \"./use-transform\"\n\ninterface ScaleMotionValues {\n    scaleX: MotionValue<number>\n    scaleY: MotionValue<number>\n}\n\n// Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\nconst maxScale = 100000\nexport const invertScale = (scale: number) =>\n    scale > 0.001 ? 1 / scale : maxScale\n\nlet hasWarned = false\n\n/**\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\n * of their respective parent scales.\n *\n * This is useful for undoing the distortion of content when scaling a parent component.\n *\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\n * of those instead.\n *\n * ```jsx\n * const MyComponent = () => {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <motion.div style={{ scaleX, scaleY }} />\n * }\n * ```\n *\n * @deprecated\n */\nexport function useInvertedScale(\n    scale?: Partial<ScaleMotionValues>\n): ScaleMotionValues {\n    let parentScaleX = useMotionValue(1)\n    let parentScaleY = useMotionValue(1)\n    const { visualElement } = useContext(MotionContext)\n\n    invariant(\n        !!(scale || visualElement),\n        \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\"\n    )\n\n    warning(\n        hasWarned,\n        \"useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.\"\n    )\n\n    hasWarned = true\n\n    if (scale) {\n        parentScaleX = scale.scaleX || parentScaleX\n        parentScaleY = scale.scaleY || parentScaleY\n    } else if (visualElement) {\n        parentScaleX = visualElement.getValue(\"scaleX\", 1)\n        parentScaleY = visualElement.getValue(\"scaleY\", 1)\n    }\n\n    const scaleX = useTransform(parentScaleX, invertScale)\n    const scaleY = useTransform(parentScaleY, invertScale)\n\n    return { scaleX, scaleY }\n}\n"],"names":[],"mappings":";;;;;;;AAcA;AACA;AACA;AACA;;AAIA;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG;AAGF;AACA;;;AAQA;;;AAQI;AACA;;;;;;;;AASJ;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-motion-template.mjs

@@ -0,0 +1,47 @@
+"use client";
+import { isMotionValue } from 'motion-dom';
+import { useCombineMotionValues } from './use-combine-values.mjs';
+
+/**
+ * Combine multiple motion values into a new one using a string template literal.
+ *
+ * ```jsx
+ * import {
+ *   motion,
+ *   useSpring,
+ *   useMotionValue,
+ *   useMotionTemplate
+ * } from "framer-motion"
+ *
+ * function Component() {
+ *   const shadowX = useSpring(0)
+ *   const shadowY = useMotionValue(0)
+ *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`
+ *
+ *   return <motion.div style={{ filter: shadow }} />
+ * }
+ * ```
+ *
+ * @public
+ */
+function useMotionTemplate(fragments, ...values) {
+    /**
+     * Create a function that will build a string from the latest motion values.
+     */
+    const numFragments = fragments.length;
+    function buildValue() {
+        let output = ``;
+        for (let i = 0; i < numFragments; i++) {
+            output += fragments[i];
+            const value = values[i];
+            if (value) {
+                output += isMotionValue(value) ? value.get() : value;
+            }
+        }
+        return output;
+    }
+    return useCombineMotionValues(values.filter(isMotionValue), buildValue);
+}
+
+export { useMotionTemplate };
+//# sourceMappingURL=use-motion-template.mjs.map

node_modules/framer-motion/dist/es/value/use-motion-template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-motion-template.mjs","sources":["../../../src/value/use-motion-template.ts"],"sourcesContent":["\"use client\"\n\nimport { isMotionValue, MotionValue } from \"motion-dom\"\nimport { useCombineMotionValues } from \"./use-combine-values\"\n\n/**\n * Combine multiple motion values into a new one using a string template literal.\n *\n * ```jsx\n * import {\n *   motion,\n *   useSpring,\n *   useMotionValue,\n *   useMotionTemplate\n * } from \"framer-motion\"\n *\n * function Component() {\n *   const shadowX = useSpring(0)\n *   const shadowY = useMotionValue(0)\n *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`\n *\n *   return <motion.div style={{ filter: shadow }} />\n * }\n * ```\n *\n * @public\n */\nexport function useMotionTemplate(\n    fragments: TemplateStringsArray,\n    ...values: Array<MotionValue | number | string>\n) {\n    /**\n     * Create a function that will build a string from the latest motion values.\n     */\n    const numFragments = fragments.length\n\n    function buildValue() {\n        let output = ``\n\n        for (let i = 0; i < numFragments; i++) {\n            output += fragments[i]\n            const value = values[i]\n            if (value) {\n                output += isMotionValue(value) ? value.get() : value\n            }\n        }\n\n        return output\n    }\n\n    return useCombineMotionValues(values.filter(isMotionValue), buildValue)\n}\n"],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;AAqBG;;AAKC;;AAEG;AACH;AAEA;;AAGI;AACI;AACA;;AAEI;;;AAIR;;;AAIR;;"}

node_modules/framer-motion/dist/es/value/use-motion-value.mjs

@@ -0,0 +1,40 @@
+"use client";
+import { motionValue } from 'motion-dom';
+import { useContext, useState, useEffect } from 'react';
+import { MotionConfigContext } from '../context/MotionConfigContext.mjs';
+import { useConstant } from '../utils/use-constant.mjs';
+
+/**
+ * Creates a `MotionValue` to track the state and velocity of a value.
+ *
+ * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.
+ *
+ * ```jsx
+ * export const MyComponent = () => {
+ *   const scale = useMotionValue(1)
+ *
+ *   return <motion.div style={{ scale }} />
+ * }
+ * ```
+ *
+ * @param initial - The initial state.
+ *
+ * @public
+ */
+function useMotionValue(initial) {
+    const value = useConstant(() => motionValue(initial));
+    /**
+     * If this motion value is being used in static mode, like on
+     * the Framer canvas, force components to rerender when the motion
+     * value is updated.
+     */
+    const { isStatic } = useContext(MotionConfigContext);
+    if (isStatic) {
+        const [, setLatest] = useState(initial);
+        useEffect(() => value.on("change", setLatest), []);
+    }
+    return value;
+}
+
+export { useMotionValue };
+//# sourceMappingURL=use-motion-value.mjs.map

node_modules/framer-motion/dist/es/value/use-motion-value.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-motion-value.mjs","sources":["../../../src/value/use-motion-value.ts"],"sourcesContent":["\"use client\"\n\nimport { motionValue, MotionValue } from \"motion-dom\"\nimport { useContext, useEffect, useState } from \"react\"\nimport { MotionConfigContext } from \"../context/MotionConfigContext\"\nimport { useConstant } from \"../utils/use-constant\"\n\n/**\n * Creates a `MotionValue` to track the state and velocity of a value.\n *\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const scale = useMotionValue(1)\n *\n *   return <motion.div style={{ scale }} />\n * }\n * ```\n *\n * @param initial - The initial state.\n *\n * @public\n */\nexport function useMotionValue<T>(initial: T): MotionValue<T> {\n    const value = useConstant(() => motionValue(initial))\n\n    /**\n     * If this motion value is being used in static mode, like on\n     * the Framer canvas, force components to rerender when the motion\n     * value is updated.\n     */\n    const { isStatic } = useContext(MotionConfigContext)\n    if (isStatic) {\n        const [, setLatest] = useState(initial)\n        useEffect(() => value.on(\"change\", setLatest), [])\n    }\n\n    return value\n}\n"],"names":[],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;;;AAgBG;AACG;AACF;AAEA;;;;AAIG;;;;AAIC;;AAGJ;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-scroll.mjs

@@ -0,0 +1,89 @@
+"use client";
+import { supportsViewTimeline, supportsScrollTimeline, motionValue } from 'motion-dom';
+import { invariant } from 'motion-utils';
+import { useRef, useCallback, useEffect } from 'react';
+import { scroll } from '../render/dom/scroll/index.mjs';
+import { offsetToViewTimelineRange } from '../render/dom/scroll/utils/offset-to-range.mjs';
+import { useConstant } from '../utils/use-constant.mjs';
+import { useIsomorphicLayoutEffect } from '../utils/use-isomorphic-effect.mjs';
+
+const createScrollMotionValues = () => ({
+    scrollX: motionValue(0),
+    scrollY: motionValue(0),
+    scrollXProgress: motionValue(0),
+    scrollYProgress: motionValue(0),
+});
+const isRefPending = (ref) => {
+    if (!ref)
+        return false;
+    return !ref.current;
+};
+function makeAccelerateConfig(axis, options, container, target) {
+    return {
+        factory: (animation) => scroll(animation, {
+            ...options,
+            axis,
+            container: container?.current || undefined,
+            target: target?.current || undefined,
+        }),
+        times: [0, 1],
+        keyframes: [0, 1],
+        ease: (v) => v,
+        duration: 1,
+    };
+}
+function canAccelerateScroll(target, offset) {
+    if (typeof window === "undefined")
+        return false;
+    return target
+        ? supportsViewTimeline() && !!offsetToViewTimelineRange(offset)
+        : supportsScrollTimeline();
+}
+function useScroll({ container, target, ...options } = {}) {
+    const values = useConstant(createScrollMotionValues);
+    if (canAccelerateScroll(target, options.offset)) {
+        values.scrollXProgress.accelerate = makeAccelerateConfig("x", options, container, target);
+        values.scrollYProgress.accelerate = makeAccelerateConfig("y", options, container, target);
+    }
+    const scrollAnimation = useRef(null);
+    const needsStart = useRef(false);
+    const start = useCallback(() => {
+        scrollAnimation.current = scroll((_progress, { x, y, }) => {
+            values.scrollX.set(x.current);
+            values.scrollXProgress.set(x.progress);
+            values.scrollY.set(y.current);
+            values.scrollYProgress.set(y.progress);
+        }, {
+            ...options,
+            container: container?.current || undefined,
+            target: target?.current || undefined,
+        });
+        return () => {
+            scrollAnimation.current?.();
+        };
+    }, [container, target, JSON.stringify(options.offset)]);
+    useIsomorphicLayoutEffect(() => {
+        needsStart.current = false;
+        if (isRefPending(container) || isRefPending(target)) {
+            needsStart.current = true;
+            return;
+        }
+        else {
+            return start();
+        }
+    }, [start]);
+    useEffect(() => {
+        if (needsStart.current) {
+            invariant(!isRefPending(container), "Container ref is defined but not hydrated", "use-scroll-ref");
+            invariant(!isRefPending(target), "Target ref is defined but not hydrated", "use-scroll-ref");
+            return start();
+        }
+        else {
+            return;
+        }
+    }, [start]);
+    return values;
+}
+
+export { useScroll };
+//# sourceMappingURL=use-scroll.mjs.map

node_modules/framer-motion/dist/es/value/use-scroll.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scroll.mjs","sources":["../../../src/value/use-scroll.ts"],"sourcesContent":["\"use client\"\n\nimport {\n    AnimationPlaybackControls,\n    motionValue,\n    supportsScrollTimeline,\n    supportsViewTimeline,\n} from \"motion-dom\"\nimport { invariant } from \"motion-utils\"\nimport { RefObject, useCallback, useEffect, useRef } from \"react\"\nimport { scroll } from \"../render/dom/scroll\"\nimport { ScrollInfoOptions } from \"../render/dom/scroll/types\"\nimport { offsetToViewTimelineRange } from \"../render/dom/scroll/utils/offset-to-range\"\nimport { useConstant } from \"../utils/use-constant\"\nimport { useIsomorphicLayoutEffect } from \"../utils/use-isomorphic-effect\"\n\nexport interface UseScrollOptions\n    extends Omit<ScrollInfoOptions, \"container\" | \"target\"> {\n    container?: RefObject<HTMLElement | null>\n    target?: RefObject<HTMLElement | null>\n}\n\nconst createScrollMotionValues = () => ({\n    scrollX: motionValue(0),\n    scrollY: motionValue(0),\n    scrollXProgress: motionValue(0),\n    scrollYProgress: motionValue(0),\n})\n\nconst isRefPending = (ref?: RefObject<HTMLElement | null>) => {\n    if (!ref) return false\n    return !ref.current\n}\n\nfunction makeAccelerateConfig(\n    axis: \"x\" | \"y\",\n    options: Omit<UseScrollOptions, \"container\" | \"target\">,\n    container?: RefObject<HTMLElement | null>,\n    target?: RefObject<HTMLElement | null>\n) {\n    return {\n        factory: (animation: AnimationPlaybackControls) =>\n            scroll(animation, {\n                ...options,\n                axis,\n                container: container?.current || undefined,\n                target: target?.current || undefined,\n            }),\n        times: [0, 1],\n        keyframes: [0, 1],\n        ease: (v: number) => v,\n        duration: 1,\n    }\n}\n\nfunction canAccelerateScroll(\n    target?: RefObject<HTMLElement | null>,\n    offset?: ScrollInfoOptions[\"offset\"]\n) {\n    if (typeof window === \"undefined\") return false\n    return target\n        ? supportsViewTimeline() && !!offsetToViewTimelineRange(offset)\n        : supportsScrollTimeline()\n}\n\nexport function useScroll({\n    container,\n    target,\n    ...options\n}: UseScrollOptions = {}) {\n    const values = useConstant(createScrollMotionValues)\n\n    if (canAccelerateScroll(target, options.offset)) {\n        values.scrollXProgress.accelerate = makeAccelerateConfig(\n            \"x\",\n            options,\n            container,\n            target\n        )\n        values.scrollYProgress.accelerate = makeAccelerateConfig(\n            \"y\",\n            options,\n            container,\n            target\n        )\n    }\n\n    const scrollAnimation = useRef<VoidFunction | null>(null)\n    const needsStart = useRef(false)\n\n    const start = useCallback(() => {\n        scrollAnimation.current = scroll(\n            (\n                _progress: number,\n                {\n                    x,\n                    y,\n                }: {\n                    x: { current: number; progress: number }\n                    y: { current: number; progress: number }\n                }\n            ) => {\n                values.scrollX.set(x.current)\n                values.scrollXProgress.set(x.progress)\n                values.scrollY.set(y.current)\n                values.scrollYProgress.set(y.progress)\n            },\n            {\n                ...options,\n                container: container?.current || undefined,\n                target: target?.current || undefined,\n            }\n        )\n\n        return () => {\n            scrollAnimation.current?.()\n        }\n    }, [container, target, JSON.stringify(options.offset)])\n\n    useIsomorphicLayoutEffect(() => {\n        needsStart.current = false\n\n        if (isRefPending(container) || isRefPending(target)) {\n            needsStart.current = true\n            return\n        } else {\n            return start()\n        }\n    }, [start])\n\n    useEffect(() => {\n        if (needsStart.current) {\n            invariant(\n                !isRefPending(container),\n                \"Container ref is defined but not hydrated\",\n                \"use-scroll-ref\"\n            )\n            invariant(\n                !isRefPending(target),\n                \"Target ref is defined but not hydrated\",\n                \"use-scroll-ref\"\n            )\n            return start()\n        } else {\n            return\n        }\n    }, [start])\n\n    return values\n}\n"],"names":[],"mappings":";;;;;;;;;AAsBA;AACI;AACA;AACA;AACA;AACH;AAED;AACI;AAAU;AACV;AACJ;AAEA;;;AASgB;;AAEA;AACA;;AAER;AACA;AACA;AACA;;AAER;AAEA;;AAIuC;AACnC;;;AAGJ;AAEM;AAKF;;AAGI;AAMA;;AAQJ;AACA;AAEA;AACI;;;;;AAeI;AAEI;AACA;AACA;AACH;AAGL;AACI;AACJ;AACJ;;AAGI;;AAGI;;;;;;AAKR;;AAGI;;;;;;;;AAeJ;AAEA;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-spring.mjs

@@ -0,0 +1,9 @@
+"use client";
+import { useFollowValue } from './use-follow-value.mjs';
+
+function useSpring(source, options = {}) {
+    return useFollowValue(source, { type: "spring", ...options });
+}
+
+export { useSpring };
+//# sourceMappingURL=use-spring.mjs.map

node_modules/framer-motion/dist/es/value/use-spring.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-spring.mjs","sources":["../../../src/value/use-spring.ts"],"sourcesContent":["\"use client\"\n\nimport { FollowValueOptions, MotionValue, SpringOptions } from \"motion-dom\"\nimport { useFollowValue } from \"./use-follow-value\"\n\ntype UseSpringOptions = SpringOptions &\n    Pick<FollowValueOptions, \"skipInitialAnimation\">\n\n/**\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\n *\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\n * to another `MotionValue`.\n *\n * @remarks\n *\n * ```jsx\n * const x = useSpring(0, { stiffness: 300 })\n * const y = useSpring(x, { damping: 10 })\n * ```\n *\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\n * @param springConfig - Configuration options for the spring.\n * @returns `MotionValue`\n *\n * @public\n */\nexport function useSpring(\n    source: MotionValue<string>,\n    options?: UseSpringOptions\n): MotionValue<string>\nexport function useSpring(\n    source: string,\n    options?: UseSpringOptions\n): MotionValue<string>\nexport function useSpring(\n    source: MotionValue<number>,\n    options?: UseSpringOptions\n): MotionValue<number>\nexport function useSpring(\n    source: number,\n    options?: UseSpringOptions\n): MotionValue<number>\nexport function useSpring(\n    source: MotionValue<string> | MotionValue<number> | string | number,\n    options: UseSpringOptions = {}\n): MotionValue<string> | MotionValue<number> {\n    return useFollowValue(source as any, { type: \"spring\", ...options })\n}\n"],"names":[],"mappings":";;;;AA+CI;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-time.mjs

@@ -0,0 +1,12 @@
+"use client";
+import { useAnimationFrame } from '../utils/use-animation-frame.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+
+function useTime() {
+    const time = useMotionValue(0);
+    useAnimationFrame((t) => time.set(t));
+    return time;
+}
+
+export { useTime };
+//# sourceMappingURL=use-time.mjs.map

node_modules/framer-motion/dist/es/value/use-time.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-time.mjs","sources":["../../../src/value/use-time.ts"],"sourcesContent":["\"use client\"\n\nimport { useAnimationFrame } from \"../utils/use-animation-frame\"\nimport { useMotionValue } from \"./use-motion-value\"\n\nexport function useTime() {\n    const time = useMotionValue(0)\n    useAnimationFrame((t) => time.set(t))\n    return time\n}\n"],"names":[],"mappings":";;;;;AAMI;AACA;AACA;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-transform.mjs

@@ -0,0 +1,70 @@
+"use client";
+import { transform } from 'motion-dom';
+import { useConstant } from '../utils/use-constant.mjs';
+import { useCombineMotionValues } from './use-combine-values.mjs';
+import { useComputed } from './use-computed.mjs';
+
+function useTransform(input, inputRangeOrTransformer, outputRangeOrMap, options) {
+    if (typeof input === "function") {
+        return useComputed(input);
+    }
+    /**
+     * Detect if outputRangeOrMap is an output map (object with keys)
+     * rather than an output range (array).
+     */
+    const isOutputMap = outputRangeOrMap !== undefined &&
+        !Array.isArray(outputRangeOrMap) &&
+        typeof inputRangeOrTransformer !== "function";
+    if (isOutputMap) {
+        return useMapTransform(input, inputRangeOrTransformer, outputRangeOrMap, options);
+    }
+    const outputRange = outputRangeOrMap;
+    const transformer = typeof inputRangeOrTransformer === "function"
+        ? inputRangeOrTransformer
+        : transform(inputRangeOrTransformer, outputRange, options);
+    const result = Array.isArray(input)
+        ? useListTransform(input, transformer)
+        : useListTransform([input], ([latest]) => transformer(latest));
+    const inputAccelerate = !Array.isArray(input)
+        ? input.accelerate
+        : undefined;
+    if (inputAccelerate &&
+        !inputAccelerate.isTransformed &&
+        typeof inputRangeOrTransformer !== "function" &&
+        Array.isArray(outputRangeOrMap) &&
+        options?.clamp !== false) {
+        result.accelerate = {
+            ...inputAccelerate,
+            times: inputRangeOrTransformer,
+            keyframes: outputRangeOrMap,
+            isTransformed: true,
+            ...(options?.ease ? { ease: options.ease } : {}),
+        };
+    }
+    return result;
+}
+function useListTransform(values, transformer) {
+    const latest = useConstant(() => []);
+    return useCombineMotionValues(values, () => {
+        latest.length = 0;
+        const numValues = values.length;
+        for (let i = 0; i < numValues; i++) {
+            latest[i] = values[i].get();
+        }
+        return transformer(latest);
+    });
+}
+function useMapTransform(inputValue, inputRange, outputMap, options) {
+    /**
+     * Capture keys once to ensure hooks are called in consistent order.
+     */
+    const keys = useConstant(() => Object.keys(outputMap));
+    const output = useConstant(() => ({}));
+    for (const key of keys) {
+        output[key] = useTransform(inputValue, inputRange, outputMap[key], options);
+    }
+    return output;
+}
+
+export { useTransform };
+//# sourceMappingURL=use-transform.mjs.map

node_modules/framer-motion/dist/es/value/use-velocity.mjs

@@ -0,0 +1,37 @@
+"use client";
+import { frame } from 'motion-dom';
+import { useMotionValueEvent } from '../utils/use-motion-value-event.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+
+/**
+ * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.
+ *
+ * ```javascript
+ * const x = useMotionValue(0)
+ * const xVelocity = useVelocity(x)
+ * const xAcceleration = useVelocity(xVelocity)
+ * ```
+ *
+ * @public
+ */
+function useVelocity(value) {
+    const velocity = useMotionValue(value.getVelocity());
+    const updateVelocity = () => {
+        const latest = value.getVelocity();
+        velocity.set(latest);
+        /**
+         * If we still have velocity, schedule an update for the next frame
+         * to keep checking until it is zero.
+         */
+        if (latest)
+            frame.update(updateVelocity);
+    };
+    useMotionValueEvent(value, "change", () => {
+        // Schedule an update to this value at the end of the current frame.
+        frame.update(updateVelocity, false, true);
+    });
+    return velocity;
+}
+
+export { useVelocity };
+//# sourceMappingURL=use-velocity.mjs.map

node_modules/framer-motion/dist/es/value/use-velocity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-velocity.mjs","sources":["../../../src/value/use-velocity.ts"],"sourcesContent":["\"use client\"\n\nimport { frame, MotionValue } from \"motion-dom\"\nimport { useMotionValueEvent } from \"../utils/use-motion-value-event\"\nimport { useMotionValue } from \"./use-motion-value\"\n/**\n * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.\n *\n * ```javascript\n * const x = useMotionValue(0)\n * const xVelocity = useVelocity(x)\n * const xAcceleration = useVelocity(xVelocity)\n * ```\n *\n * @public\n */\nexport function useVelocity(value: MotionValue<number>): MotionValue<number> {\n    const velocity = useMotionValue(value.getVelocity())\n\n    const updateVelocity = () => {\n        const latest = value.getVelocity()\n        velocity.set(latest)\n\n        /**\n         * If we still have velocity, schedule an update for the next frame\n         * to keep checking until it is zero.\n         */\n        if (latest) frame.update(updateVelocity)\n    }\n\n    useMotionValueEvent(value, \"change\", () => {\n        // Schedule an update to this value at the end of the current frame.\n        frame.update(updateVelocity, false, true)\n    })\n\n    return velocity\n}\n"],"names":[],"mappings":";;;;;AAKA;;;;;;;;;;AAUG;AACG;;;AAIE;AACA;AAEA;;;AAGG;AACH;AAAY;AAChB;AAEA;;;AAGA;AAEA;AACJ;;"}

node_modules/framer-motion/dist/es/value/use-will-change/WillChangeMotionValue.mjs

@@ -0,0 +1,20 @@
+import { MotionValue, transformProps, acceleratedValues } from 'motion-dom';
+
+class WillChangeMotionValue extends MotionValue {
+    constructor() {
+        super(...arguments);
+        this.isEnabled = false;
+    }
+    add(name) {
+        if (transformProps.has(name) || acceleratedValues.has(name)) {
+            this.isEnabled = true;
+            this.update();
+        }
+    }
+    update() {
+        this.set(this.isEnabled ? "transform" : "auto");
+    }
+}
+
+export { WillChangeMotionValue };
+//# sourceMappingURL=WillChangeMotionValue.mjs.map

node_modules/framer-motion/dist/es/value/use-will-change/WillChangeMotionValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WillChangeMotionValue.mjs","sources":["../../../../src/value/use-will-change/WillChangeMotionValue.ts"],"sourcesContent":["import {\n    acceleratedValues,\n    MotionValue,\n    transformProps,\n    type WillChange,\n} from \"motion-dom\"\n\nexport class WillChangeMotionValue\n    extends MotionValue<string>\n    implements WillChange\n{\n    private isEnabled = false\n\n    add(name: string) {\n        if (transformProps.has(name) || acceleratedValues.has(name)) {\n            this.isEnabled = true\n            this.update()\n        }\n    }\n\n    private update() {\n        this.set(this.isEnabled ? \"transform\" : \"auto\")\n    }\n}\n"],"names":[],"mappings":";;AAOM,MAAO,qBACT,SAAQ,WAAmB,CAAA;AAD/B,IAAA,WAAA,GAAA;;QAIY,IAAA,CAAA,SAAS,GAAG,KAAK;IAY7B;AAVI,IAAA,GAAG,CAAC,IAAY,EAAA;AACZ,QAAA,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACzD,YAAA,IAAI,CAAC,SAAS,GAAG,IAAI;YACrB,IAAI,CAAC,MAAM,EAAE;QACjB;IACJ;IAEQ,MAAM,GAAA;AACV,QAAA,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,WAAW,GAAG,MAAM,CAAC;IACnD;AACH;;;;"}

node_modules/framer-motion/dist/es/value/use-will-change/index.mjs

@@ -0,0 +1,10 @@
+"use client";
+import { useConstant } from '../../utils/use-constant.mjs';
+import { WillChangeMotionValue } from './WillChangeMotionValue.mjs';
+
+function useWillChange() {
+    return useConstant(() => new WillChangeMotionValue("auto"));
+}
+
+export { useWillChange };
+//# sourceMappingURL=index.mjs.map

node_modules/framer-motion/dist/es/value/use-will-change/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../src/value/use-will-change/index.ts"],"sourcesContent":["\"use client\"\n\nimport type { WillChange } from \"motion-dom\"\nimport { useConstant } from \"../../utils/use-constant\"\nimport { WillChangeMotionValue } from \"./WillChangeMotionValue\"\n\nexport function useWillChange(): WillChange {\n    return useConstant(() => new WillChangeMotionValue(\"auto\"))\n}\n"],"names":[],"mappings":";;;;;;AAQA;;"}