main repo

node_modules/framer-motion/dist/es/render/VisualElement.mjs

@@ -0,0 +1,477 @@
+import { KeyframeResolver, time, frame, isMotionValue, cancelFrame, transformProps, motionValue, findValueType, complex, getAnimatableNone, microtask } from 'motion-dom';
+import { warnOnce, isNumericalString, isZeroValueString, SubscriptionManager } from 'motion-utils';
+import { featureDefinitions } from '../motion/features/definitions.mjs';
+import { createBox } from '../projection/geometry/models.mjs';
+import { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';
+import { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';
+import { visualElementStore } from './store.mjs';
+import { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';
+import { updateMotionValuesFromProps } from './utils/motion-values.mjs';
+import { resolveVariantFromProps } from './utils/resolve-variants.mjs';
+
+const propEventHandlers = [
+    "AnimationStart",
+    "AnimationComplete",
+    "Update",
+    "BeforeLayoutMeasure",
+    "LayoutMeasure",
+    "LayoutAnimationStart",
+    "LayoutAnimationComplete",
+];
+/**
+ * A VisualElement is an imperative abstraction around UI elements such as
+ * HTMLElement, SVGElement, Three.Object3D etc.
+ */
+class VisualElement {
+    /**
+     * This method takes React props and returns found MotionValues. For example, HTML
+     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+     *
+     * This isn't an abstract method as it needs calling in the constructor, but it is
+     * intended to be one.
+     */
+    scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {
+        return {};
+    }
+    constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, visualState, }, options = {}) {
+        /**
+         * A reference to the current underlying Instance, e.g. a HTMLElement
+         * or Three.Mesh etc.
+         */
+        this.current = null;
+        /**
+         * A set containing references to this VisualElement's children.
+         */
+        this.children = new Set();
+        /**
+         * Determine what role this visual element should take in the variant tree.
+         */
+        this.isVariantNode = false;
+        this.isControllingVariants = false;
+        /**
+         * Decides whether this VisualElement should animate in reduced motion
+         * mode.
+         *
+         * TODO: This is currently set on every individual VisualElement but feels
+         * like it could be set globally.
+         */
+        this.shouldReduceMotion = null;
+        /**
+         * A map of all motion values attached to this visual element. Motion
+         * values are source of truth for any given animated value. A motion
+         * value might be provided externally by the component via props.
+         */
+        this.values = new Map();
+        this.KeyframeResolver = KeyframeResolver;
+        /**
+         * Cleanup functions for active features (hover/tap/exit etc)
+         */
+        this.features = {};
+        /**
+         * A map of every subscription that binds the provided or generated
+         * motion values onChange listeners to this visual element.
+         */
+        this.valueSubscriptions = new Map();
+        /**
+         * A reference to the previously-provided motion values as returned
+         * from scrapeMotionValuesFromProps. We use the keys in here to determine
+         * if any motion values need to be removed after props are updated.
+         */
+        this.prevMotionValues = {};
+        /**
+         * An object containing a SubscriptionManager for each active event.
+         */
+        this.events = {};
+        /**
+         * An object containing an unsubscribe function for each prop event subscription.
+         * For example, every "Update" event can have multiple subscribers via
+         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.
+         */
+        this.propEventSubscriptions = {};
+        this.notifyUpdate = () => this.notify("Update", this.latestValues);
+        this.render = () => {
+            if (!this.current)
+                return;
+            this.triggerBuild();
+            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);
+        };
+        this.renderScheduledAt = 0.0;
+        this.scheduleRender = () => {
+            const now = time.now();
+            if (this.renderScheduledAt < now) {
+                this.renderScheduledAt = now;
+                frame.render(this.render, false, true);
+            }
+        };
+        const { latestValues, renderState } = visualState;
+        this.latestValues = latestValues;
+        this.baseTarget = { ...latestValues };
+        this.initialValues = props.initial ? { ...latestValues } : {};
+        this.renderState = renderState;
+        this.parent = parent;
+        this.props = props;
+        this.presenceContext = presenceContext;
+        this.depth = parent ? parent.depth + 1 : 0;
+        this.reducedMotionConfig = reducedMotionConfig;
+        this.options = options;
+        this.blockInitialAnimation = Boolean(blockInitialAnimation);
+        this.isControllingVariants = isControllingVariants(props);
+        this.isVariantNode = isVariantNode(props);
+        if (this.isVariantNode) {
+            this.variantChildren = new Set();
+        }
+        this.manuallyAnimateOnMount = Boolean(parent && parent.current);
+        /**
+         * Any motion values that are provided to the element when created
+         * aren't yet bound to the element, as this would technically be impure.
+         * However, we iterate through the motion values and set them to the
+         * initial values for this component.
+         *
+         * TODO: This is impure and we should look at changing this to run on mount.
+         * Doing so will break some tests but this isn't necessarily a breaking change,
+         * more a reflection of the test.
+         */
+        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);
+        for (const key in initialMotionValues) {
+            const value = initialMotionValues[key];
+            if (latestValues[key] !== undefined && isMotionValue(value)) {
+                value.set(latestValues[key]);
+            }
+        }
+    }
+    mount(instance) {
+        this.current = instance;
+        visualElementStore.set(instance, this);
+        if (this.projection && !this.projection.instance) {
+            this.projection.mount(instance);
+        }
+        if (this.parent && this.isVariantNode && !this.isControllingVariants) {
+            this.removeFromVariantTree = this.parent.addVariantChild(this);
+        }
+        this.values.forEach((value, key) => this.bindToMotionValue(key, value));
+        if (!hasReducedMotionListener.current) {
+            initPrefersReducedMotion();
+        }
+        this.shouldReduceMotion =
+            this.reducedMotionConfig === "never"
+                ? false
+                : this.reducedMotionConfig === "always"
+                    ? true
+                    : prefersReducedMotion.current;
+        if (process.env.NODE_ENV !== "production") {
+            warnOnce(this.shouldReduceMotion !== true, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled");
+        }
+        this.parent?.addChild(this);
+        this.update(this.props, this.presenceContext);
+    }
+    unmount() {
+        this.projection && this.projection.unmount();
+        cancelFrame(this.notifyUpdate);
+        cancelFrame(this.render);
+        this.valueSubscriptions.forEach((remove) => remove());
+        this.valueSubscriptions.clear();
+        this.removeFromVariantTree && this.removeFromVariantTree();
+        this.parent?.removeChild(this);
+        for (const key in this.events) {
+            this.events[key].clear();
+        }
+        for (const key in this.features) {
+            const feature = this.features[key];
+            if (feature) {
+                feature.unmount();
+                feature.isMounted = false;
+            }
+        }
+        this.current = null;
+    }
+    addChild(child) {
+        this.children.add(child);
+        this.enteringChildren ?? (this.enteringChildren = new Set());
+        this.enteringChildren.add(child);
+    }
+    removeChild(child) {
+        this.children.delete(child);
+        this.enteringChildren && this.enteringChildren.delete(child);
+    }
+    bindToMotionValue(key, value) {
+        if (this.valueSubscriptions.has(key)) {
+            this.valueSubscriptions.get(key)();
+        }
+        const valueIsTransform = transformProps.has(key);
+        if (valueIsTransform && this.onBindTransform) {
+            this.onBindTransform();
+        }
+        const removeOnChange = value.on("change", (latestValue) => {
+            this.latestValues[key] = latestValue;
+            this.props.onUpdate && frame.preRender(this.notifyUpdate);
+            if (valueIsTransform && this.projection) {
+                this.projection.isTransformDirty = true;
+            }
+            this.scheduleRender();
+        });
+        let removeSyncCheck;
+        if (window.MotionCheckAppearSync) {
+            removeSyncCheck = window.MotionCheckAppearSync(this, key, value);
+        }
+        this.valueSubscriptions.set(key, () => {
+            removeOnChange();
+            if (removeSyncCheck)
+                removeSyncCheck();
+            if (value.owner)
+                value.stop();
+        });
+    }
+    sortNodePosition(other) {
+        /**
+         * If these nodes aren't even of the same type we can't compare their depth.
+         */
+        if (!this.current ||
+            !this.sortInstanceNodePosition ||
+            this.type !== other.type) {
+            return 0;
+        }
+        return this.sortInstanceNodePosition(this.current, other.current);
+    }
+    updateFeatures() {
+        let key = "animation";
+        for (key in featureDefinitions) {
+            const featureDefinition = featureDefinitions[key];
+            if (!featureDefinition)
+                continue;
+            const { isEnabled, Feature: FeatureConstructor } = featureDefinition;
+            /**
+             * If this feature is enabled but not active, make a new instance.
+             */
+            if (!this.features[key] &&
+                FeatureConstructor &&
+                isEnabled(this.props)) {
+                this.features[key] = new FeatureConstructor(this);
+            }
+            /**
+             * If we have a feature, mount or update it.
+             */
+            if (this.features[key]) {
+                const feature = this.features[key];
+                if (feature.isMounted) {
+                    feature.update();
+                }
+                else {
+                    feature.mount();
+                    feature.isMounted = true;
+                }
+            }
+        }
+    }
+    triggerBuild() {
+        this.build(this.renderState, this.latestValues, this.props);
+    }
+    /**
+     * Measure the current viewport box with or without transforms.
+     * Only measures axis-aligned boxes, rotate and skew must be manually
+     * removed with a re-render to work.
+     */
+    measureViewportBox() {
+        return this.current
+            ? this.measureInstanceViewportBox(this.current, this.props)
+            : createBox();
+    }
+    getStaticValue(key) {
+        return this.latestValues[key];
+    }
+    setStaticValue(key, value) {
+        this.latestValues[key] = value;
+    }
+    /**
+     * Update the provided props. Ensure any newly-added motion values are
+     * added to our map, old ones removed, and listeners updated.
+     */
+    update(props, presenceContext) {
+        if (props.transformTemplate || this.props.transformTemplate) {
+            this.scheduleRender();
+        }
+        this.prevProps = this.props;
+        this.props = props;
+        this.prevPresenceContext = this.presenceContext;
+        this.presenceContext = presenceContext;
+        /**
+         * Update prop event handlers ie onAnimationStart, onAnimationComplete
+         */
+        for (let i = 0; i < propEventHandlers.length; i++) {
+            const key = propEventHandlers[i];
+            if (this.propEventSubscriptions[key]) {
+                this.propEventSubscriptions[key]();
+                delete this.propEventSubscriptions[key];
+            }
+            const listenerName = ("on" + key);
+            const listener = props[listenerName];
+            if (listener) {
+                this.propEventSubscriptions[key] = this.on(key, listener);
+            }
+        }
+        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);
+        if (this.handleChildMotionValue) {
+            this.handleChildMotionValue();
+        }
+    }
+    getProps() {
+        return this.props;
+    }
+    /**
+     * Returns the variant definition with a given name.
+     */
+    getVariant(name) {
+        return this.props.variants ? this.props.variants[name] : undefined;
+    }
+    /**
+     * Returns the defined default transition on this component.
+     */
+    getDefaultTransition() {
+        return this.props.transition;
+    }
+    getTransformPagePoint() {
+        return this.props.transformPagePoint;
+    }
+    getClosestVariantNode() {
+        return this.isVariantNode
+            ? this
+            : this.parent
+                ? this.parent.getClosestVariantNode()
+                : undefined;
+    }
+    /**
+     * Add a child visual element to our set of children.
+     */
+    addVariantChild(child) {
+        const closestVariantNode = this.getClosestVariantNode();
+        if (closestVariantNode) {
+            closestVariantNode.variantChildren &&
+                closestVariantNode.variantChildren.add(child);
+            return () => closestVariantNode.variantChildren.delete(child);
+        }
+    }
+    /**
+     * Add a motion value and bind it to this visual element.
+     */
+    addValue(key, value) {
+        // Remove existing value if it exists
+        const existingValue = this.values.get(key);
+        if (value !== existingValue) {
+            if (existingValue)
+                this.removeValue(key);
+            this.bindToMotionValue(key, value);
+            this.values.set(key, value);
+            this.latestValues[key] = value.get();
+        }
+    }
+    /**
+     * Remove a motion value and unbind any active subscriptions.
+     */
+    removeValue(key) {
+        this.values.delete(key);
+        const unsubscribe = this.valueSubscriptions.get(key);
+        if (unsubscribe) {
+            unsubscribe();
+            this.valueSubscriptions.delete(key);
+        }
+        delete this.latestValues[key];
+        this.removeValueFromRenderState(key, this.renderState);
+    }
+    /**
+     * Check whether we have a motion value for this key
+     */
+    hasValue(key) {
+        return this.values.has(key);
+    }
+    getValue(key, defaultValue) {
+        if (this.props.values && this.props.values[key]) {
+            return this.props.values[key];
+        }
+        let value = this.values.get(key);
+        if (value === undefined && defaultValue !== undefined) {
+            value = motionValue(defaultValue === null ? undefined : defaultValue, { owner: this });
+            this.addValue(key, value);
+        }
+        return value;
+    }
+    /**
+     * If we're trying to animate to a previously unencountered value,
+     * we need to check for it in our state and as a last resort read it
+     * directly from the instance (which might have performance implications).
+     */
+    readValue(key, target) {
+        let value = this.latestValues[key] !== undefined || !this.current
+            ? this.latestValues[key]
+            : this.getBaseTargetFromProps(this.props, key) ??
+                this.readValueFromInstance(this.current, key, this.options);
+        if (value !== undefined && value !== null) {
+            if (typeof value === "string" &&
+                (isNumericalString(value) || isZeroValueString(value))) {
+                // If this is a number read as a string, ie "0" or "200", convert it to a number
+                value = parseFloat(value);
+            }
+            else if (!findValueType(value) && complex.test(target)) {
+                value = getAnimatableNone(key, target);
+            }
+            this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);
+        }
+        return isMotionValue(value) ? value.get() : value;
+    }
+    /**
+     * Set the base target to later animate back to. This is currently
+     * only hydrated on creation and when we first read a value.
+     */
+    setBaseTarget(key, value) {
+        this.baseTarget[key] = value;
+    }
+    /**
+     * Find the base target for a value thats been removed from all animation
+     * props.
+     */
+    getBaseTarget(key) {
+        const { initial } = this.props;
+        let valueFromInitial;
+        if (typeof initial === "string" || typeof initial === "object") {
+            const variant = resolveVariantFromProps(this.props, initial, this.presenceContext?.custom);
+            if (variant) {
+                valueFromInitial = variant[key];
+            }
+        }
+        /**
+         * If this value still exists in the current initial variant, read that.
+         */
+        if (initial && valueFromInitial !== undefined) {
+            return valueFromInitial;
+        }
+        /**
+         * Alternatively, if this VisualElement config has defined a getBaseTarget
+         * so we can read the value from an alternative source, try that.
+         */
+        const target = this.getBaseTargetFromProps(this.props, key);
+        if (target !== undefined && !isMotionValue(target))
+            return target;
+        /**
+         * If the value was initially defined on initial, but it doesn't any more,
+         * return undefined. Otherwise return the value as initially read from the DOM.
+         */
+        return this.initialValues[key] !== undefined &&
+            valueFromInitial === undefined
+            ? undefined
+            : this.baseTarget[key];
+    }
+    on(eventName, callback) {
+        if (!this.events[eventName]) {
+            this.events[eventName] = new SubscriptionManager();
+        }
+        return this.events[eventName].add(callback);
+    }
+    notify(eventName, ...args) {
+        if (this.events[eventName]) {
+            this.events[eventName].notify(...args);
+        }
+    }
+    scheduleRenderMicrotask() {
+        microtask.render(this.render);
+    }
+}
+
+export { VisualElement };

node_modules/framer-motion/dist/es/render/components/create-proxy.mjs

@@ -0,0 +1,45 @@
+import { warnOnce } from 'motion-utils';
+import { createMotionComponent } from '../../motion/index.mjs';
+
+function createMotionProxy(preloadedFeatures, createVisualElement) {
+    if (typeof Proxy === "undefined") {
+        return createMotionComponent;
+    }
+    /**
+     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.
+     * Rather than generating them anew every render.
+     */
+    const componentCache = new Map();
+    const factory = (Component, options) => {
+        return createMotionComponent(Component, options, preloadedFeatures, createVisualElement);
+    };
+    /**
+     * Support for deprecated`motion(Component)` pattern
+     */
+    const deprecatedFactoryFunction = (Component, options) => {
+        if (process.env.NODE_ENV !== "production") {
+            warnOnce(false, "motion() is deprecated. Use motion.create() instead.");
+        }
+        return factory(Component, options);
+    };
+    return new Proxy(deprecatedFactoryFunction, {
+        /**
+         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+         * The prop name is passed through as `key` and we can use that to generate a `motion`
+         * DOM component with that name.
+         */
+        get: (_target, key) => {
+            if (key === "create")
+                return factory;
+            /**
+             * If this element doesn't exist in the component cache, create it and cache.
+             */
+            if (!componentCache.has(key)) {
+                componentCache.set(key, createMotionComponent(key, undefined, preloadedFeatures, createVisualElement));
+            }
+            return componentCache.get(key);
+        },
+    });
+}
+
+export { createMotionProxy };

node_modules/framer-motion/dist/es/render/components/m/create.mjs

@@ -0,0 +1,7 @@
+import { createMotionComponent } from '../../../motion/index.mjs';
+
+function createMinimalMotionComponent(Component, options) {
+    return createMotionComponent(Component, options);
+}
+
+export { createMinimalMotionComponent };

node_modules/framer-motion/dist/es/render/components/m/elements.mjs

@@ -0,0 +1,227 @@
+"use client";
+import { createMinimalMotionComponent } from './create.mjs';
+
+/**
+ * HTML components
+ */
+const MotionA = /*@__PURE__*/ createMinimalMotionComponent("a");
+const MotionAbbr = /*@__PURE__*/ createMinimalMotionComponent("abbr");
+const MotionAddress = 
+/*@__PURE__*/ createMinimalMotionComponent("address");
+const MotionArea = /*@__PURE__*/ createMinimalMotionComponent("area");
+const MotionArticle = 
+/*@__PURE__*/ createMinimalMotionComponent("article");
+const MotionAside = /*@__PURE__*/ createMinimalMotionComponent("aside");
+const MotionAudio = /*@__PURE__*/ createMinimalMotionComponent("audio");
+const MotionB = /*@__PURE__*/ createMinimalMotionComponent("b");
+const MotionBase = /*@__PURE__*/ createMinimalMotionComponent("base");
+const MotionBdi = /*@__PURE__*/ createMinimalMotionComponent("bdi");
+const MotionBdo = /*@__PURE__*/ createMinimalMotionComponent("bdo");
+const MotionBig = /*@__PURE__*/ createMinimalMotionComponent("big");
+const MotionBlockquote = 
+/*@__PURE__*/ createMinimalMotionComponent("blockquote");
+const MotionBody = /*@__PURE__*/ createMinimalMotionComponent("body");
+const MotionButton = /*@__PURE__*/ createMinimalMotionComponent("button");
+const MotionCanvas = /*@__PURE__*/ createMinimalMotionComponent("canvas");
+const MotionCaption = 
+/*@__PURE__*/ createMinimalMotionComponent("caption");
+const MotionCite = /*@__PURE__*/ createMinimalMotionComponent("cite");
+const MotionCode = /*@__PURE__*/ createMinimalMotionComponent("code");
+const MotionCol = /*@__PURE__*/ createMinimalMotionComponent("col");
+const MotionColgroup = 
+/*@__PURE__*/ createMinimalMotionComponent("colgroup");
+const MotionData = /*@__PURE__*/ createMinimalMotionComponent("data");
+const MotionDatalist = 
+/*@__PURE__*/ createMinimalMotionComponent("datalist");
+const MotionDd = /*@__PURE__*/ createMinimalMotionComponent("dd");
+const MotionDel = /*@__PURE__*/ createMinimalMotionComponent("del");
+const MotionDetails = 
+/*@__PURE__*/ createMinimalMotionComponent("details");
+const MotionDfn = /*@__PURE__*/ createMinimalMotionComponent("dfn");
+const MotionDialog = /*@__PURE__*/ createMinimalMotionComponent("dialog");
+const MotionDiv = /*@__PURE__*/ createMinimalMotionComponent("div");
+const MotionDl = /*@__PURE__*/ createMinimalMotionComponent("dl");
+const MotionDt = /*@__PURE__*/ createMinimalMotionComponent("dt");
+const MotionEm = /*@__PURE__*/ createMinimalMotionComponent("em");
+const MotionEmbed = /*@__PURE__*/ createMinimalMotionComponent("embed");
+const MotionFieldset = 
+/*@__PURE__*/ createMinimalMotionComponent("fieldset");
+const MotionFigcaption = 
+/*@__PURE__*/ createMinimalMotionComponent("figcaption");
+const MotionFigure = /*@__PURE__*/ createMinimalMotionComponent("figure");
+const MotionFooter = /*@__PURE__*/ createMinimalMotionComponent("footer");
+const MotionForm = /*@__PURE__*/ createMinimalMotionComponent("form");
+const MotionH1 = /*@__PURE__*/ createMinimalMotionComponent("h1");
+const MotionH2 = /*@__PURE__*/ createMinimalMotionComponent("h2");
+const MotionH3 = /*@__PURE__*/ createMinimalMotionComponent("h3");
+const MotionH4 = /*@__PURE__*/ createMinimalMotionComponent("h4");
+const MotionH5 = /*@__PURE__*/ createMinimalMotionComponent("h5");
+const MotionH6 = /*@__PURE__*/ createMinimalMotionComponent("h6");
+const MotionHead = /*@__PURE__*/ createMinimalMotionComponent("head");
+const MotionHeader = /*@__PURE__*/ createMinimalMotionComponent("header");
+const MotionHgroup = /*@__PURE__*/ createMinimalMotionComponent("hgroup");
+const MotionHr = /*@__PURE__*/ createMinimalMotionComponent("hr");
+const MotionHtml = /*@__PURE__*/ createMinimalMotionComponent("html");
+const MotionI = /*@__PURE__*/ createMinimalMotionComponent("i");
+const MotionIframe = /*@__PURE__*/ createMinimalMotionComponent("iframe");
+const MotionImg = /*@__PURE__*/ createMinimalMotionComponent("img");
+const MotionInput = /*@__PURE__*/ createMinimalMotionComponent("input");
+const MotionIns = /*@__PURE__*/ createMinimalMotionComponent("ins");
+const MotionKbd = /*@__PURE__*/ createMinimalMotionComponent("kbd");
+const MotionKeygen = /*@__PURE__*/ createMinimalMotionComponent("keygen");
+const MotionLabel = /*@__PURE__*/ createMinimalMotionComponent("label");
+const MotionLegend = /*@__PURE__*/ createMinimalMotionComponent("legend");
+const MotionLi = /*@__PURE__*/ createMinimalMotionComponent("li");
+const MotionLink = /*@__PURE__*/ createMinimalMotionComponent("link");
+const MotionMain = /*@__PURE__*/ createMinimalMotionComponent("main");
+const MotionMap = /*@__PURE__*/ createMinimalMotionComponent("map");
+const MotionMark = /*@__PURE__*/ createMinimalMotionComponent("mark");
+const MotionMenu = /*@__PURE__*/ createMinimalMotionComponent("menu");
+const MotionMenuitem = 
+/*@__PURE__*/ createMinimalMotionComponent("menuitem");
+const MotionMeter = /*@__PURE__*/ createMinimalMotionComponent("meter");
+const MotionNav = /*@__PURE__*/ createMinimalMotionComponent("nav");
+const MotionObject = /*@__PURE__*/ createMinimalMotionComponent("object");
+const MotionOl = /*@__PURE__*/ createMinimalMotionComponent("ol");
+const MotionOptgroup = 
+/*@__PURE__*/ createMinimalMotionComponent("optgroup");
+const MotionOption = /*@__PURE__*/ createMinimalMotionComponent("option");
+const MotionOutput = /*@__PURE__*/ createMinimalMotionComponent("output");
+const MotionP = /*@__PURE__*/ createMinimalMotionComponent("p");
+const MotionParam = /*@__PURE__*/ createMinimalMotionComponent("param");
+const MotionPicture = 
+/*@__PURE__*/ createMinimalMotionComponent("picture");
+const MotionPre = /*@__PURE__*/ createMinimalMotionComponent("pre");
+const MotionProgress = 
+/*@__PURE__*/ createMinimalMotionComponent("progress");
+const MotionQ = /*@__PURE__*/ createMinimalMotionComponent("q");
+const MotionRp = /*@__PURE__*/ createMinimalMotionComponent("rp");
+const MotionRt = /*@__PURE__*/ createMinimalMotionComponent("rt");
+const MotionRuby = /*@__PURE__*/ createMinimalMotionComponent("ruby");
+const MotionS = /*@__PURE__*/ createMinimalMotionComponent("s");
+const MotionSamp = /*@__PURE__*/ createMinimalMotionComponent("samp");
+const MotionScript = /*@__PURE__*/ createMinimalMotionComponent("script");
+const MotionSection = 
+/*@__PURE__*/ createMinimalMotionComponent("section");
+const MotionSelect = /*@__PURE__*/ createMinimalMotionComponent("select");
+const MotionSmall = /*@__PURE__*/ createMinimalMotionComponent("small");
+const MotionSource = /*@__PURE__*/ createMinimalMotionComponent("source");
+const MotionSpan = /*@__PURE__*/ createMinimalMotionComponent("span");
+const MotionStrong = /*@__PURE__*/ createMinimalMotionComponent("strong");
+const MotionStyle = /*@__PURE__*/ createMinimalMotionComponent("style");
+const MotionSub = /*@__PURE__*/ createMinimalMotionComponent("sub");
+const MotionSummary = 
+/*@__PURE__*/ createMinimalMotionComponent("summary");
+const MotionSup = /*@__PURE__*/ createMinimalMotionComponent("sup");
+const MotionTable = /*@__PURE__*/ createMinimalMotionComponent("table");
+const MotionTbody = /*@__PURE__*/ createMinimalMotionComponent("tbody");
+const MotionTd = /*@__PURE__*/ createMinimalMotionComponent("td");
+const MotionTextarea = 
+/*@__PURE__*/ createMinimalMotionComponent("textarea");
+const MotionTfoot = /*@__PURE__*/ createMinimalMotionComponent("tfoot");
+const MotionTh = /*@__PURE__*/ createMinimalMotionComponent("th");
+const MotionThead = /*@__PURE__*/ createMinimalMotionComponent("thead");
+const MotionTime = /*@__PURE__*/ createMinimalMotionComponent("time");
+const MotionTitle = /*@__PURE__*/ createMinimalMotionComponent("title");
+const MotionTr = /*@__PURE__*/ createMinimalMotionComponent("tr");
+const MotionTrack = /*@__PURE__*/ createMinimalMotionComponent("track");
+const MotionU = /*@__PURE__*/ createMinimalMotionComponent("u");
+const MotionUl = /*@__PURE__*/ createMinimalMotionComponent("ul");
+const MotionVideo = /*@__PURE__*/ createMinimalMotionComponent("video");
+const MotionWbr = /*@__PURE__*/ createMinimalMotionComponent("wbr");
+const MotionWebview = 
+/*@__PURE__*/ createMinimalMotionComponent("webview");
+/**
+ * SVG components
+ */
+const MotionAnimate = 
+/*@__PURE__*/ createMinimalMotionComponent("animate");
+const MotionCircle = /*@__PURE__*/ createMinimalMotionComponent("circle");
+const MotionDefs = /*@__PURE__*/ createMinimalMotionComponent("defs");
+const MotionDesc = /*@__PURE__*/ createMinimalMotionComponent("desc");
+const MotionEllipse = 
+/*@__PURE__*/ createMinimalMotionComponent("ellipse");
+const MotionG = /*@__PURE__*/ createMinimalMotionComponent("g");
+const MotionImage = /*@__PURE__*/ createMinimalMotionComponent("image");
+const MotionLine = /*@__PURE__*/ createMinimalMotionComponent("line");
+const MotionFilter = /*@__PURE__*/ createMinimalMotionComponent("filter");
+const MotionMarker = /*@__PURE__*/ createMinimalMotionComponent("marker");
+const MotionMask = /*@__PURE__*/ createMinimalMotionComponent("mask");
+const MotionMetadata = 
+/*@__PURE__*/ createMinimalMotionComponent("metadata");
+const MotionPath = /*@__PURE__*/ createMinimalMotionComponent("path");
+const MotionPattern = 
+/*@__PURE__*/ createMinimalMotionComponent("pattern");
+const MotionPolygon = 
+/*@__PURE__*/ createMinimalMotionComponent("polygon");
+const MotionPolyline = 
+/*@__PURE__*/ createMinimalMotionComponent("polyline");
+const MotionRect = /*@__PURE__*/ createMinimalMotionComponent("rect");
+const MotionStop = /*@__PURE__*/ createMinimalMotionComponent("stop");
+const MotionSvg = /*@__PURE__*/ createMinimalMotionComponent("svg");
+const MotionSymbol = /*@__PURE__*/ createMinimalMotionComponent("symbol");
+const MotionText = /*@__PURE__*/ createMinimalMotionComponent("text");
+const MotionTspan = /*@__PURE__*/ createMinimalMotionComponent("tspan");
+const MotionUse = /*@__PURE__*/ createMinimalMotionComponent("use");
+const MotionView = /*@__PURE__*/ createMinimalMotionComponent("view");
+const MotionClipPath = 
+/*@__PURE__*/ createMinimalMotionComponent("clipPath");
+const MotionFeBlend = 
+/*@__PURE__*/ createMinimalMotionComponent("feBlend");
+const MotionFeColorMatrix = 
+/*@__PURE__*/ createMinimalMotionComponent("feColorMatrix");
+const MotionFeComponentTransfer = 
+/*@__PURE__*/ createMinimalMotionComponent("feComponentTransfer");
+const MotionFeComposite = 
+/*@__PURE__*/ createMinimalMotionComponent("feComposite");
+const MotionFeConvolveMatrix = 
+/*@__PURE__*/ createMinimalMotionComponent("feConvolveMatrix");
+const MotionFeDiffuseLighting = 
+/*@__PURE__*/ createMinimalMotionComponent("feDiffuseLighting");
+const MotionFeDisplacementMap = 
+/*@__PURE__*/ createMinimalMotionComponent("feDisplacementMap");
+const MotionFeDistantLight = 
+/*@__PURE__*/ createMinimalMotionComponent("feDistantLight");
+const MotionFeDropShadow = 
+/*@__PURE__*/ createMinimalMotionComponent("feDropShadow");
+const MotionFeFlood = 
+/*@__PURE__*/ createMinimalMotionComponent("feFlood");
+const MotionFeFuncA = 
+/*@__PURE__*/ createMinimalMotionComponent("feFuncA");
+const MotionFeFuncB = 
+/*@__PURE__*/ createMinimalMotionComponent("feFuncB");
+const MotionFeFuncG = 
+/*@__PURE__*/ createMinimalMotionComponent("feFuncG");
+const MotionFeFuncR = 
+/*@__PURE__*/ createMinimalMotionComponent("feFuncR");
+const MotionFeGaussianBlur = 
+/*@__PURE__*/ createMinimalMotionComponent("feGaussianBlur");
+const MotionFeImage = 
+/*@__PURE__*/ createMinimalMotionComponent("feImage");
+const MotionFeMerge = 
+/*@__PURE__*/ createMinimalMotionComponent("feMerge");
+const MotionFeMergeNode = 
+/*@__PURE__*/ createMinimalMotionComponent("feMergeNode");
+const MotionFeMorphology = 
+/*@__PURE__*/ createMinimalMotionComponent("feMorphology");
+const MotionFeOffset = 
+/*@__PURE__*/ createMinimalMotionComponent("feOffset");
+const MotionFePointLight = 
+/*@__PURE__*/ createMinimalMotionComponent("fePointLight");
+const MotionFeSpecularLighting = 
+/*@__PURE__*/ createMinimalMotionComponent("feSpecularLighting");
+const MotionFeSpotLight = 
+/*@__PURE__*/ createMinimalMotionComponent("feSpotLight");
+const MotionFeTile = /*@__PURE__*/ createMinimalMotionComponent("feTile");
+const MotionFeTurbulence = 
+/*@__PURE__*/ createMinimalMotionComponent("feTurbulence");
+const MotionForeignObject = 
+/*@__PURE__*/ createMinimalMotionComponent("foreignObject");
+const MotionLinearGradient = 
+/*@__PURE__*/ createMinimalMotionComponent("linearGradient");
+const MotionRadialGradient = 
+/*@__PURE__*/ createMinimalMotionComponent("radialGradient");
+const MotionTextPath = 
+/*@__PURE__*/ createMinimalMotionComponent("textPath");
+
+export { MotionA, MotionAbbr, MotionAddress, MotionAnimate, MotionArea, MotionArticle, MotionAside, MotionAudio, MotionB, MotionBase, MotionBdi, MotionBdo, MotionBig, MotionBlockquote, MotionBody, MotionButton, MotionCanvas, MotionCaption, MotionCircle, MotionCite, MotionClipPath, MotionCode, MotionCol, MotionColgroup, MotionData, MotionDatalist, MotionDd, MotionDefs, MotionDel, MotionDesc, MotionDetails, MotionDfn, MotionDialog, MotionDiv, MotionDl, MotionDt, MotionEllipse, MotionEm, MotionEmbed, MotionFeBlend, MotionFeColorMatrix, MotionFeComponentTransfer, MotionFeComposite, MotionFeConvolveMatrix, MotionFeDiffuseLighting, MotionFeDisplacementMap, MotionFeDistantLight, MotionFeDropShadow, MotionFeFlood, MotionFeFuncA, MotionFeFuncB, MotionFeFuncG, MotionFeFuncR, MotionFeGaussianBlur, MotionFeImage, MotionFeMerge, MotionFeMergeNode, MotionFeMorphology, MotionFeOffset, MotionFePointLight, MotionFeSpecularLighting, MotionFeSpotLight, MotionFeTile, MotionFeTurbulence, MotionFieldset, MotionFigcaption, MotionFigure, MotionFilter, MotionFooter, MotionForeignObject, MotionForm, MotionG, MotionH1, MotionH2, MotionH3, MotionH4, MotionH5, MotionH6, MotionHead, MotionHeader, MotionHgroup, MotionHr, MotionHtml, MotionI, MotionIframe, MotionImage, MotionImg, MotionInput, MotionIns, MotionKbd, MotionKeygen, MotionLabel, MotionLegend, MotionLi, MotionLine, MotionLinearGradient, MotionLink, MotionMain, MotionMap, MotionMark, MotionMarker, MotionMask, MotionMenu, MotionMenuitem, MotionMetadata, MotionMeter, MotionNav, MotionObject, MotionOl, MotionOptgroup, MotionOption, MotionOutput, MotionP, MotionParam, MotionPath, MotionPattern, MotionPicture, MotionPolygon, MotionPolyline, MotionPre, MotionProgress, MotionQ, MotionRadialGradient, MotionRect, MotionRp, MotionRt, MotionRuby, MotionS, MotionSamp, MotionScript, MotionSection, MotionSelect, MotionSmall, MotionSource, MotionSpan, MotionStop, MotionStrong, MotionStyle, MotionSub, MotionSummary, MotionSup, MotionSvg, MotionSymbol, MotionTable, MotionTbody, MotionTd, MotionText, MotionTextPath, MotionTextarea, MotionTfoot, MotionTh, MotionThead, MotionTime, MotionTitle, MotionTr, MotionTrack, MotionTspan, MotionU, MotionUl, MotionUse, MotionVideo, MotionView, MotionWbr, MotionWebview };

node_modules/framer-motion/dist/es/render/components/m/proxy.mjs

@@ -0,0 +1,5 @@
+import { createMotionProxy } from '../create-proxy.mjs';
+
+const m = /*@__PURE__*/ createMotionProxy();
+
+export { m };

node_modules/framer-motion/dist/es/render/components/motion/create.mjs

@@ -0,0 +1,9 @@
+import { createMotionComponent } from '../../../motion/index.mjs';
+import { createDomVisualElement } from '../../dom/create-visual-element.mjs';
+import { featureBundle } from './feature-bundle.mjs';
+
+function createMotionComponentWithFeatures(Component, options) {
+    return createMotionComponent(Component, options, featureBundle, createDomVisualElement);
+}
+
+export { createMotionComponentWithFeatures };

node_modules/framer-motion/dist/es/render/components/motion/elements.mjs

@@ -0,0 +1,194 @@
+"use client";
+import { createMotionComponentWithFeatures } from './create.mjs';
+
+/**
+ * HTML components
+ */
+const MotionA = /*@__PURE__*/ createMotionComponentWithFeatures("a");
+const MotionAbbr = /*@__PURE__*/ createMotionComponentWithFeatures("abbr");
+const MotionAddress = /*@__PURE__*/ createMotionComponentWithFeatures("address");
+const MotionArea = /*@__PURE__*/ createMotionComponentWithFeatures("area");
+const MotionArticle = /*@__PURE__*/ createMotionComponentWithFeatures("article");
+const MotionAside = /*@__PURE__*/ createMotionComponentWithFeatures("aside");
+const MotionAudio = /*@__PURE__*/ createMotionComponentWithFeatures("audio");
+const MotionB = /*@__PURE__*/ createMotionComponentWithFeatures("b");
+const MotionBase = /*@__PURE__*/ createMotionComponentWithFeatures("base");
+const MotionBdi = /*@__PURE__*/ createMotionComponentWithFeatures("bdi");
+const MotionBdo = /*@__PURE__*/ createMotionComponentWithFeatures("bdo");
+const MotionBig = /*@__PURE__*/ createMotionComponentWithFeatures("big");
+const MotionBlockquote = 
+/*@__PURE__*/ createMotionComponentWithFeatures("blockquote");
+const MotionBody = /*@__PURE__*/ createMotionComponentWithFeatures("body");
+const MotionButton = /*@__PURE__*/ createMotionComponentWithFeatures("button");
+const MotionCanvas = /*@__PURE__*/ createMotionComponentWithFeatures("canvas");
+const MotionCaption = /*@__PURE__*/ createMotionComponentWithFeatures("caption");
+const MotionCite = /*@__PURE__*/ createMotionComponentWithFeatures("cite");
+const MotionCode = /*@__PURE__*/ createMotionComponentWithFeatures("code");
+const MotionCol = /*@__PURE__*/ createMotionComponentWithFeatures("col");
+const MotionColgroup = /*@__PURE__*/ createMotionComponentWithFeatures("colgroup");
+const MotionData = /*@__PURE__*/ createMotionComponentWithFeatures("data");
+const MotionDatalist = /*@__PURE__*/ createMotionComponentWithFeatures("datalist");
+const MotionDd = /*@__PURE__*/ createMotionComponentWithFeatures("dd");
+const MotionDel = /*@__PURE__*/ createMotionComponentWithFeatures("del");
+const MotionDetails = /*@__PURE__*/ createMotionComponentWithFeatures("details");
+const MotionDfn = /*@__PURE__*/ createMotionComponentWithFeatures("dfn");
+const MotionDialog = /*@__PURE__*/ createMotionComponentWithFeatures("dialog");
+const MotionDiv = /*@__PURE__*/ createMotionComponentWithFeatures("div");
+const MotionDl = /*@__PURE__*/ createMotionComponentWithFeatures("dl");
+const MotionDt = /*@__PURE__*/ createMotionComponentWithFeatures("dt");
+const MotionEm = /*@__PURE__*/ createMotionComponentWithFeatures("em");
+const MotionEmbed = /*@__PURE__*/ createMotionComponentWithFeatures("embed");
+const MotionFieldset = /*@__PURE__*/ createMotionComponentWithFeatures("fieldset");
+const MotionFigcaption = 
+/*@__PURE__*/ createMotionComponentWithFeatures("figcaption");
+const MotionFigure = /*@__PURE__*/ createMotionComponentWithFeatures("figure");
+const MotionFooter = /*@__PURE__*/ createMotionComponentWithFeatures("footer");
+const MotionForm = /*@__PURE__*/ createMotionComponentWithFeatures("form");
+const MotionH1 = /*@__PURE__*/ createMotionComponentWithFeatures("h1");
+const MotionH2 = /*@__PURE__*/ createMotionComponentWithFeatures("h2");
+const MotionH3 = /*@__PURE__*/ createMotionComponentWithFeatures("h3");
+const MotionH4 = /*@__PURE__*/ createMotionComponentWithFeatures("h4");
+const MotionH5 = /*@__PURE__*/ createMotionComponentWithFeatures("h5");
+const MotionH6 = /*@__PURE__*/ createMotionComponentWithFeatures("h6");
+const MotionHead = /*@__PURE__*/ createMotionComponentWithFeatures("head");
+const MotionHeader = /*@__PURE__*/ createMotionComponentWithFeatures("header");
+const MotionHgroup = /*@__PURE__*/ createMotionComponentWithFeatures("hgroup");
+const MotionHr = /*@__PURE__*/ createMotionComponentWithFeatures("hr");
+const MotionHtml = /*@__PURE__*/ createMotionComponentWithFeatures("html");
+const MotionI = /*@__PURE__*/ createMotionComponentWithFeatures("i");
+const MotionIframe = /*@__PURE__*/ createMotionComponentWithFeatures("iframe");
+const MotionImg = /*@__PURE__*/ createMotionComponentWithFeatures("img");
+const MotionInput = /*@__PURE__*/ createMotionComponentWithFeatures("input");
+const MotionIns = /*@__PURE__*/ createMotionComponentWithFeatures("ins");
+const MotionKbd = /*@__PURE__*/ createMotionComponentWithFeatures("kbd");
+const MotionKeygen = /*@__PURE__*/ createMotionComponentWithFeatures("keygen");
+const MotionLabel = /*@__PURE__*/ createMotionComponentWithFeatures("label");
+const MotionLegend = /*@__PURE__*/ createMotionComponentWithFeatures("legend");
+const MotionLi = /*@__PURE__*/ createMotionComponentWithFeatures("li");
+const MotionLink = /*@__PURE__*/ createMotionComponentWithFeatures("link");
+const MotionMain = /*@__PURE__*/ createMotionComponentWithFeatures("main");
+const MotionMap = /*@__PURE__*/ createMotionComponentWithFeatures("map");
+const MotionMark = /*@__PURE__*/ createMotionComponentWithFeatures("mark");
+const MotionMenu = /*@__PURE__*/ createMotionComponentWithFeatures("menu");
+const MotionMenuitem = /*@__PURE__*/ createMotionComponentWithFeatures("menuitem");
+const MotionMeter = /*@__PURE__*/ createMotionComponentWithFeatures("meter");
+const MotionNav = /*@__PURE__*/ createMotionComponentWithFeatures("nav");
+const MotionObject = /*@__PURE__*/ createMotionComponentWithFeatures("object");
+const MotionOl = /*@__PURE__*/ createMotionComponentWithFeatures("ol");
+const MotionOptgroup = /*@__PURE__*/ createMotionComponentWithFeatures("optgroup");
+const MotionOption = /*@__PURE__*/ createMotionComponentWithFeatures("option");
+const MotionOutput = /*@__PURE__*/ createMotionComponentWithFeatures("output");
+const MotionP = /*@__PURE__*/ createMotionComponentWithFeatures("p");
+const MotionParam = /*@__PURE__*/ createMotionComponentWithFeatures("param");
+const MotionPicture = /*@__PURE__*/ createMotionComponentWithFeatures("picture");
+const MotionPre = /*@__PURE__*/ createMotionComponentWithFeatures("pre");
+const MotionProgress = /*@__PURE__*/ createMotionComponentWithFeatures("progress");
+const MotionQ = /*@__PURE__*/ createMotionComponentWithFeatures("q");
+const MotionRp = /*@__PURE__*/ createMotionComponentWithFeatures("rp");
+const MotionRt = /*@__PURE__*/ createMotionComponentWithFeatures("rt");
+const MotionRuby = /*@__PURE__*/ createMotionComponentWithFeatures("ruby");
+const MotionS = /*@__PURE__*/ createMotionComponentWithFeatures("s");
+const MotionSamp = /*@__PURE__*/ createMotionComponentWithFeatures("samp");
+const MotionScript = /*@__PURE__*/ createMotionComponentWithFeatures("script");
+const MotionSection = /*@__PURE__*/ createMotionComponentWithFeatures("section");
+const MotionSelect = /*@__PURE__*/ createMotionComponentWithFeatures("select");
+const MotionSmall = /*@__PURE__*/ createMotionComponentWithFeatures("small");
+const MotionSource = /*@__PURE__*/ createMotionComponentWithFeatures("source");
+const MotionSpan = /*@__PURE__*/ createMotionComponentWithFeatures("span");
+const MotionStrong = /*@__PURE__*/ createMotionComponentWithFeatures("strong");
+const MotionStyle = /*@__PURE__*/ createMotionComponentWithFeatures("style");
+const MotionSub = /*@__PURE__*/ createMotionComponentWithFeatures("sub");
+const MotionSummary = /*@__PURE__*/ createMotionComponentWithFeatures("summary");
+const MotionSup = /*@__PURE__*/ createMotionComponentWithFeatures("sup");
+const MotionTable = /*@__PURE__*/ createMotionComponentWithFeatures("table");
+const MotionTbody = /*@__PURE__*/ createMotionComponentWithFeatures("tbody");
+const MotionTd = /*@__PURE__*/ createMotionComponentWithFeatures("td");
+const MotionTextarea = /*@__PURE__*/ createMotionComponentWithFeatures("textarea");
+const MotionTfoot = /*@__PURE__*/ createMotionComponentWithFeatures("tfoot");
+const MotionTh = /*@__PURE__*/ createMotionComponentWithFeatures("th");
+const MotionThead = /*@__PURE__*/ createMotionComponentWithFeatures("thead");
+const MotionTime = /*@__PURE__*/ createMotionComponentWithFeatures("time");
+const MotionTitle = /*@__PURE__*/ createMotionComponentWithFeatures("title");
+const MotionTr = /*@__PURE__*/ createMotionComponentWithFeatures("tr");
+const MotionTrack = /*@__PURE__*/ createMotionComponentWithFeatures("track");
+const MotionU = /*@__PURE__*/ createMotionComponentWithFeatures("u");
+const MotionUl = /*@__PURE__*/ createMotionComponentWithFeatures("ul");
+const MotionVideo = /*@__PURE__*/ createMotionComponentWithFeatures("video");
+const MotionWbr = /*@__PURE__*/ createMotionComponentWithFeatures("wbr");
+const MotionWebview = /*@__PURE__*/ createMotionComponentWithFeatures("webview");
+/**
+ * SVG components
+ */
+const MotionAnimate = /*@__PURE__*/ createMotionComponentWithFeatures("animate");
+const MotionCircle = /*@__PURE__*/ createMotionComponentWithFeatures("circle");
+const MotionDefs = /*@__PURE__*/ createMotionComponentWithFeatures("defs");
+const MotionDesc = /*@__PURE__*/ createMotionComponentWithFeatures("desc");
+const MotionEllipse = /*@__PURE__*/ createMotionComponentWithFeatures("ellipse");
+const MotionG = /*@__PURE__*/ createMotionComponentWithFeatures("g");
+const MotionImage = /*@__PURE__*/ createMotionComponentWithFeatures("image");
+const MotionLine = /*@__PURE__*/ createMotionComponentWithFeatures("line");
+const MotionFilter = /*@__PURE__*/ createMotionComponentWithFeatures("filter");
+const MotionMarker = /*@__PURE__*/ createMotionComponentWithFeatures("marker");
+const MotionMask = /*@__PURE__*/ createMotionComponentWithFeatures("mask");
+const MotionMetadata = /*@__PURE__*/ createMotionComponentWithFeatures("metadata");
+const MotionPath = /*@__PURE__*/ createMotionComponentWithFeatures("path");
+const MotionPattern = /*@__PURE__*/ createMotionComponentWithFeatures("pattern");
+const MotionPolygon = /*@__PURE__*/ createMotionComponentWithFeatures("polygon");
+const MotionPolyline = /*@__PURE__*/ createMotionComponentWithFeatures("polyline");
+const MotionRect = /*@__PURE__*/ createMotionComponentWithFeatures("rect");
+const MotionStop = /*@__PURE__*/ createMotionComponentWithFeatures("stop");
+const MotionSvg = /*@__PURE__*/ createMotionComponentWithFeatures("svg");
+const MotionSymbol = /*@__PURE__*/ createMotionComponentWithFeatures("symbol");
+const MotionText = /*@__PURE__*/ createMotionComponentWithFeatures("text");
+const MotionTspan = /*@__PURE__*/ createMotionComponentWithFeatures("tspan");
+const MotionUse = /*@__PURE__*/ createMotionComponentWithFeatures("use");
+const MotionView = /*@__PURE__*/ createMotionComponentWithFeatures("view");
+const MotionClipPath = /*@__PURE__*/ createMotionComponentWithFeatures("clipPath");
+const MotionFeBlend = /*@__PURE__*/ createMotionComponentWithFeatures("feBlend");
+const MotionFeColorMatrix = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feColorMatrix");
+const MotionFeComponentTransfer = /*@__PURE__*/ createMotionComponentWithFeatures("feComponentTransfer");
+const MotionFeComposite = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feComposite");
+const MotionFeConvolveMatrix = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feConvolveMatrix");
+const MotionFeDiffuseLighting = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDiffuseLighting");
+const MotionFeDisplacementMap = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDisplacementMap");
+const MotionFeDistantLight = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDistantLight");
+const MotionFeDropShadow = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDropShadow");
+const MotionFeFlood = /*@__PURE__*/ createMotionComponentWithFeatures("feFlood");
+const MotionFeFuncA = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncA");
+const MotionFeFuncB = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncB");
+const MotionFeFuncG = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncG");
+const MotionFeFuncR = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncR");
+const MotionFeGaussianBlur = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feGaussianBlur");
+const MotionFeImage = /*@__PURE__*/ createMotionComponentWithFeatures("feImage");
+const MotionFeMerge = /*@__PURE__*/ createMotionComponentWithFeatures("feMerge");
+const MotionFeMergeNode = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feMergeNode");
+const MotionFeMorphology = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feMorphology");
+const MotionFeOffset = /*@__PURE__*/ createMotionComponentWithFeatures("feOffset");
+const MotionFePointLight = 
+/*@__PURE__*/ createMotionComponentWithFeatures("fePointLight");
+const MotionFeSpecularLighting = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feSpecularLighting");
+const MotionFeSpotLight = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feSpotLight");
+const MotionFeTile = /*@__PURE__*/ createMotionComponentWithFeatures("feTile");
+const MotionFeTurbulence = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feTurbulence");
+const MotionForeignObject = 
+/*@__PURE__*/ createMotionComponentWithFeatures("foreignObject");
+const MotionLinearGradient = 
+/*@__PURE__*/ createMotionComponentWithFeatures("linearGradient");
+const MotionRadialGradient = 
+/*@__PURE__*/ createMotionComponentWithFeatures("radialGradient");
+const MotionTextPath = /*@__PURE__*/ createMotionComponentWithFeatures("textPath");
+
+export { MotionA, MotionAbbr, MotionAddress, MotionAnimate, MotionArea, MotionArticle, MotionAside, MotionAudio, MotionB, MotionBase, MotionBdi, MotionBdo, MotionBig, MotionBlockquote, MotionBody, MotionButton, MotionCanvas, MotionCaption, MotionCircle, MotionCite, MotionClipPath, MotionCode, MotionCol, MotionColgroup, MotionData, MotionDatalist, MotionDd, MotionDefs, MotionDel, MotionDesc, MotionDetails, MotionDfn, MotionDialog, MotionDiv, MotionDl, MotionDt, MotionEllipse, MotionEm, MotionEmbed, MotionFeBlend, MotionFeColorMatrix, MotionFeComponentTransfer, MotionFeComposite, MotionFeConvolveMatrix, MotionFeDiffuseLighting, MotionFeDisplacementMap, MotionFeDistantLight, MotionFeDropShadow, MotionFeFlood, MotionFeFuncA, MotionFeFuncB, MotionFeFuncG, MotionFeFuncR, MotionFeGaussianBlur, MotionFeImage, MotionFeMerge, MotionFeMergeNode, MotionFeMorphology, MotionFeOffset, MotionFePointLight, MotionFeSpecularLighting, MotionFeSpotLight, MotionFeTile, MotionFeTurbulence, MotionFieldset, MotionFigcaption, MotionFigure, MotionFilter, MotionFooter, MotionForeignObject, MotionForm, MotionG, MotionH1, MotionH2, MotionH3, MotionH4, MotionH5, MotionH6, MotionHead, MotionHeader, MotionHgroup, MotionHr, MotionHtml, MotionI, MotionIframe, MotionImage, MotionImg, MotionInput, MotionIns, MotionKbd, MotionKeygen, MotionLabel, MotionLegend, MotionLi, MotionLine, MotionLinearGradient, MotionLink, MotionMain, MotionMap, MotionMark, MotionMarker, MotionMask, MotionMenu, MotionMenuitem, MotionMetadata, MotionMeter, MotionNav, MotionObject, MotionOl, MotionOptgroup, MotionOption, MotionOutput, MotionP, MotionParam, MotionPath, MotionPattern, MotionPicture, MotionPolygon, MotionPolyline, MotionPre, MotionProgress, MotionQ, MotionRadialGradient, MotionRect, MotionRp, MotionRt, MotionRuby, MotionS, MotionSamp, MotionScript, MotionSection, MotionSelect, MotionSmall, MotionSource, MotionSpan, MotionStop, MotionStrong, MotionStyle, MotionSub, MotionSummary, MotionSup, MotionSvg, MotionSymbol, MotionTable, MotionTbody, MotionTd, MotionText, MotionTextPath, MotionTextarea, MotionTfoot, MotionTh, MotionThead, MotionTime, MotionTitle, MotionTr, MotionTrack, MotionTspan, MotionU, MotionUl, MotionUse, MotionVideo, MotionView, MotionWbr, MotionWebview };

node_modules/framer-motion/dist/es/render/components/motion/feature-bundle.mjs

@@ -0,0 +1,13 @@
+import { animations } from '../../../motion/features/animations.mjs';
+import { drag } from '../../../motion/features/drag.mjs';
+import { gestureAnimations } from '../../../motion/features/gestures.mjs';
+import { layout } from '../../../motion/features/layout.mjs';
+
+const featureBundle = {
+    ...animations,
+    ...gestureAnimations,
+    ...drag,
+    ...layout,
+};
+
+export { featureBundle };

node_modules/framer-motion/dist/es/render/components/motion/proxy.mjs

@@ -0,0 +1,7 @@
+import { createDomVisualElement } from '../../dom/create-visual-element.mjs';
+import { createMotionProxy } from '../create-proxy.mjs';
+import { featureBundle } from './feature-bundle.mjs';
+
+const motion = /*@__PURE__*/ createMotionProxy(featureBundle, createDomVisualElement);
+
+export { motion };

node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs

@@ -0,0 +1,42 @@
+import { DOMKeyframesResolver, isMotionValue } from 'motion-dom';
+import { VisualElement } from '../VisualElement.mjs';
+
+class DOMVisualElement extends VisualElement {
+    constructor() {
+        super(...arguments);
+        this.KeyframeResolver = DOMKeyframesResolver;
+    }
+    sortInstanceNodePosition(a, b) {
+        /**
+         * compareDocumentPosition returns a bitmask, by using the bitwise &
+         * we're returning true if 2 in that bitmask is set to true. 2 is set
+         * to true if b preceeds a.
+         */
+        return a.compareDocumentPosition(b) & 2 ? 1 : -1;
+    }
+    getBaseTargetFromProps(props, key) {
+        return props.style
+            ? props.style[key]
+            : undefined;
+    }
+    removeValueFromRenderState(key, { vars, style }) {
+        delete vars[key];
+        delete style[key];
+    }
+    handleChildMotionValue() {
+        if (this.childSubscription) {
+            this.childSubscription();
+            delete this.childSubscription;
+        }
+        const { children } = this.props;
+        if (isMotionValue(children)) {
+            this.childSubscription = children.on("change", (latest) => {
+                if (this.current) {
+                    this.current.textContent = `${latest}`;
+                }
+            });
+        }
+    }
+}
+
+export { DOMVisualElement };

node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs

@@ -0,0 +1,14 @@
+import { Fragment } from 'react';
+import { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';
+import { SVGVisualElement } from '../svg/SVGVisualElement.mjs';
+import { isSVGComponent } from './utils/is-svg-component.mjs';
+
+const createDomVisualElement = (Component, options) => {
+    return isSVGComponent(Component)
+        ? new SVGVisualElement(options)
+        : new HTMLVisualElement(options, {
+            allowProjection: Component !== Fragment,
+        });
+};
+
+export { createDomVisualElement };

node_modules/framer-motion/dist/es/render/dom/features-animation.mjs

@@ -0,0 +1,15 @@
+"use client";
+import { animations } from '../../motion/features/animations.mjs';
+import { gestureAnimations } from '../../motion/features/gestures.mjs';
+import { createDomVisualElement } from './create-visual-element.mjs';
+
+/**
+ * @public
+ */
+const domAnimation = {
+    renderer: createDomVisualElement,
+    ...animations,
+    ...gestureAnimations,
+};
+
+export { domAnimation };

node_modules/framer-motion/dist/es/render/dom/features-max.mjs

@@ -0,0 +1,15 @@
+"use client";
+import { drag } from '../../motion/features/drag.mjs';
+import { layout } from '../../motion/features/layout.mjs';
+import { domAnimation } from './features-animation.mjs';
+
+/**
+ * @public
+ */
+const domMax = {
+    ...domAnimation,
+    ...drag,
+    ...layout,
+};
+
+export { domMax };

node_modules/framer-motion/dist/es/render/dom/features-min.mjs

@@ -0,0 +1,13 @@
+"use client";
+import { animations } from '../../motion/features/animations.mjs';
+import { createDomVisualElement } from './create-visual-element.mjs';
+
+/**
+ * @public
+ */
+const domMin = {
+    renderer: createDomVisualElement,
+    ...animations,
+};
+
+export { domMin };

node_modules/framer-motion/dist/es/render/dom/scroll/attach-animation.mjs

@@ -0,0 +1,18 @@
+import { observeTimeline } from 'motion-dom';
+import { getTimeline } from './utils/get-timeline.mjs';
+
+function attachToAnimation(animation, options) {
+    const timeline = getTimeline(options);
+    return animation.attachTimeline({
+        timeline: options.target ? undefined : timeline,
+        observe: (valueAnimation) => {
+            valueAnimation.pause();
+            return observeTimeline((progress) => {
+                valueAnimation.time =
+                    valueAnimation.iterationDuration * progress;
+            }, timeline);
+        },
+    });
+}
+
+export { attachToAnimation };

node_modules/framer-motion/dist/es/render/dom/scroll/attach-function.mjs

@@ -0,0 +1,23 @@
+import { observeTimeline } from 'motion-dom';
+import { scrollInfo } from './track.mjs';
+import { getTimeline } from './utils/get-timeline.mjs';
+
+/**
+ * If the onScroll function has two arguments, it's expecting
+ * more specific information about the scroll from scrollInfo.
+ */
+function isOnScrollWithInfo(onScroll) {
+    return onScroll.length === 2;
+}
+function attachToFunction(onScroll, options) {
+    if (isOnScrollWithInfo(onScroll)) {
+        return scrollInfo((info) => {
+            onScroll(info[options.axis].progress, info);
+        }, options);
+    }
+    else {
+        return observeTimeline(onScroll, getTimeline(options));
+    }
+}
+
+export { attachToFunction };

node_modules/framer-motion/dist/es/render/dom/scroll/index.mjs

@@ -0,0 +1,14 @@
+import { noop } from 'motion-utils';
+import { attachToAnimation } from './attach-animation.mjs';
+import { attachToFunction } from './attach-function.mjs';
+
+function scroll(onScroll, { axis = "y", container = document.scrollingElement, ...options } = {}) {
+    if (!container)
+        return noop;
+    const optionsWithDefaults = { axis, container, ...options };
+    return typeof onScroll === "function"
+        ? attachToFunction(onScroll, optionsWithDefaults)
+        : attachToAnimation(onScroll, optionsWithDefaults);
+}
+
+export { scroll };

node_modules/framer-motion/dist/es/render/dom/scroll/info.mjs

@@ -0,0 +1,55 @@
+import { progress, velocityPerSecond } from 'motion-utils';
+
+/**
+ * A time in milliseconds, beyond which we consider the scroll velocity to be 0.
+ */
+const maxElapsed = 50;
+const createAxisInfo = () => ({
+    current: 0,
+    offset: [],
+    progress: 0,
+    scrollLength: 0,
+    targetOffset: 0,
+    targetLength: 0,
+    containerLength: 0,
+    velocity: 0,
+});
+const createScrollInfo = () => ({
+    time: 0,
+    x: createAxisInfo(),
+    y: createAxisInfo(),
+});
+const keys = {
+    x: {
+        length: "Width",
+        position: "Left",
+    },
+    y: {
+        length: "Height",
+        position: "Top",
+    },
+};
+function updateAxisInfo(element, axisName, info, time) {
+    const axis = info[axisName];
+    const { length, position } = keys[axisName];
+    const prev = axis.current;
+    const prevTime = info.time;
+    axis.current = element[`scroll${position}`];
+    axis.scrollLength = element[`scroll${length}`] - element[`client${length}`];
+    axis.offset.length = 0;
+    axis.offset[0] = 0;
+    axis.offset[1] = axis.scrollLength;
+    axis.progress = progress(0, axis.scrollLength, axis.current);
+    const elapsed = time - prevTime;
+    axis.velocity =
+        elapsed > maxElapsed
+            ? 0
+            : velocityPerSecond(axis.current - prev, elapsed);
+}
+function updateScrollInfo(element, info, time) {
+    updateAxisInfo(element, "x", info, time);
+    updateAxisInfo(element, "y", info, time);
+    info.time = time;
+}
+
+export { createScrollInfo, updateScrollInfo };

node_modules/framer-motion/dist/es/render/dom/scroll/offsets/edge.mjs

@@ -0,0 +1,45 @@
+const namedEdges = {
+    start: 0,
+    center: 0.5,
+    end: 1,
+};
+function resolveEdge(edge, length, inset = 0) {
+    let delta = 0;
+    /**
+     * If we have this edge defined as a preset, replace the definition
+     * with the numerical value.
+     */
+    if (edge in namedEdges) {
+        edge = namedEdges[edge];
+    }
+    /**
+     * Handle unit values
+     */
+    if (typeof edge === "string") {
+        const asNumber = parseFloat(edge);
+        if (edge.endsWith("px")) {
+            delta = asNumber;
+        }
+        else if (edge.endsWith("%")) {
+            edge = asNumber / 100;
+        }
+        else if (edge.endsWith("vw")) {
+            delta = (asNumber / 100) * document.documentElement.clientWidth;
+        }
+        else if (edge.endsWith("vh")) {
+            delta = (asNumber / 100) * document.documentElement.clientHeight;
+        }
+        else {
+            edge = asNumber;
+        }
+    }
+    /**
+     * If the edge is defined as a number, handle as a progress value.
+     */
+    if (typeof edge === "number") {
+        delta = length * edge;
+    }
+    return inset + delta;
+}
+
+export { namedEdges, resolveEdge };

node_modules/framer-motion/dist/es/render/dom/scroll/offsets/index.mjs

@@ -0,0 +1,59 @@
+import { interpolate, defaultOffset } from 'motion-dom';
+import { clamp } from 'motion-utils';
+import { calcInset } from './inset.mjs';
+import { resolveOffset } from './offset.mjs';
+import { ScrollOffset } from './presets.mjs';
+
+const point = { x: 0, y: 0 };
+function getTargetSize(target) {
+    return "getBBox" in target && target.tagName !== "svg"
+        ? target.getBBox()
+        : { width: target.clientWidth, height: target.clientHeight };
+}
+function resolveOffsets(container, info, options) {
+    const { offset: offsetDefinition = ScrollOffset.All } = options;
+    const { target = container, axis = "y" } = options;
+    const lengthLabel = axis === "y" ? "height" : "width";
+    const inset = target !== container ? calcInset(target, container) : point;
+    /**
+     * Measure the target and container. If they're the same thing then we
+     * use the container's scrollWidth/Height as the target, from there
+     * all other calculations can remain the same.
+     */
+    const targetSize = target === container
+        ? { width: container.scrollWidth, height: container.scrollHeight }
+        : getTargetSize(target);
+    const containerSize = {
+        width: container.clientWidth,
+        height: container.clientHeight,
+    };
+    /**
+     * Reset the length of the resolved offset array rather than creating a new one.
+     * TODO: More reusable data structures for targetSize/containerSize would also be good.
+     */
+    info[axis].offset.length = 0;
+    /**
+     * Populate the offset array by resolving the user's offset definition into
+     * a list of pixel scroll offets.
+     */
+    let hasChanged = !info[axis].interpolate;
+    const numOffsets = offsetDefinition.length;
+    for (let i = 0; i < numOffsets; i++) {
+        const offset = resolveOffset(offsetDefinition[i], containerSize[lengthLabel], targetSize[lengthLabel], inset[axis]);
+        if (!hasChanged && offset !== info[axis].interpolatorOffsets[i]) {
+            hasChanged = true;
+        }
+        info[axis].offset[i] = offset;
+    }
+    /**
+     * If the pixel scroll offsets have changed, create a new interpolator function
+     * to map scroll value into a progress.
+     */
+    if (hasChanged) {
+        info[axis].interpolate = interpolate(info[axis].offset, defaultOffset(offsetDefinition), { clamp: false });
+        info[axis].interpolatorOffsets = [...info[axis].offset];
+    }
+    info[axis].progress = clamp(0, 1, info[axis].interpolate(info[axis].current));
+}
+
+export { resolveOffsets };

node_modules/framer-motion/dist/es/render/dom/scroll/offsets/inset.mjs

@@ -0,0 +1,47 @@
+import { isHTMLElement } from 'motion-dom';
+
+function calcInset(element, container) {
+    const inset = { x: 0, y: 0 };
+    let current = element;
+    while (current && current !== container) {
+        if (isHTMLElement(current)) {
+            inset.x += current.offsetLeft;
+            inset.y += current.offsetTop;
+            current = current.offsetParent;
+        }
+        else if (current.tagName === "svg") {
+            /**
+             * This isn't an ideal approach to measuring the offset of <svg /> tags.
+             * It would be preferable, given they behave like HTMLElements in most ways
+             * to use offsetLeft/Top. But these don't exist on <svg />. Likewise we
+             * can't use .getBBox() like most SVG elements as these provide the offset
+             * relative to the SVG itself, which for <svg /> is usually 0x0.
+             */
+            const svgBoundingBox = current.getBoundingClientRect();
+            current = current.parentElement;
+            const parentBoundingBox = current.getBoundingClientRect();
+            inset.x += svgBoundingBox.left - parentBoundingBox.left;
+            inset.y += svgBoundingBox.top - parentBoundingBox.top;
+        }
+        else if (current instanceof SVGGraphicsElement) {
+            const { x, y } = current.getBBox();
+            inset.x += x;
+            inset.y += y;
+            let svg = null;
+            let parent = current.parentNode;
+            while (!svg) {
+                if (parent.tagName === "svg") {
+                    svg = parent;
+                }
+                parent = current.parentNode;
+            }
+            current = svg;
+        }
+        else {
+            break;
+        }
+    }
+    return inset;
+}
+
+export { calcInset };

node_modules/framer-motion/dist/es/render/dom/scroll/offsets/offset.mjs

@@ -0,0 +1,35 @@
+import { resolveEdge, namedEdges } from './edge.mjs';
+
+const defaultOffset = [0, 0];
+function resolveOffset(offset, containerLength, targetLength, targetInset) {
+    let offsetDefinition = Array.isArray(offset) ? offset : defaultOffset;
+    let targetPoint = 0;
+    let containerPoint = 0;
+    if (typeof offset === "number") {
+        /**
+         * If we're provided offset: [0, 0.5, 1] then each number x should become
+         * [x, x], so we default to the behaviour of mapping 0 => 0 of both target
+         * and container etc.
+         */
+        offsetDefinition = [offset, offset];
+    }
+    else if (typeof offset === "string") {
+        offset = offset.trim();
+        if (offset.includes(" ")) {
+            offsetDefinition = offset.split(" ");
+        }
+        else {
+            /**
+             * If we're provided a definition like "100px" then we want to apply
+             * that only to the top of the target point, leaving the container at 0.
+             * Whereas a named offset like "end" should be applied to both.
+             */
+            offsetDefinition = [offset, namedEdges[offset] ? offset : `0`];
+        }
+    }
+    targetPoint = resolveEdge(offsetDefinition[0], targetLength, targetInset);
+    containerPoint = resolveEdge(offsetDefinition[1], containerLength);
+    return targetPoint - containerPoint;
+}
+
+export { resolveOffset };

node_modules/framer-motion/dist/es/render/dom/scroll/offsets/presets.mjs

@@ -0,0 +1,20 @@
+const ScrollOffset = {
+    Enter: [
+        [0, 1],
+        [1, 1],
+    ],
+    Exit: [
+        [0, 0],
+        [1, 0],
+    ],
+    Any: [
+        [1, 0],
+        [0, 1],
+    ],
+    All: [
+        [0, 0],
+        [1, 1],
+    ],
+};
+
+export { ScrollOffset };

node_modules/framer-motion/dist/es/render/dom/scroll/on-scroll-handler.mjs

@@ -0,0 +1,48 @@
+import { warnOnce } from 'motion-utils';
+import { updateScrollInfo } from './info.mjs';
+import { resolveOffsets } from './offsets/index.mjs';
+
+function measure(container, target = container, info) {
+    /**
+     * Find inset of target within scrollable container
+     */
+    info.x.targetOffset = 0;
+    info.y.targetOffset = 0;
+    if (target !== container) {
+        let node = target;
+        while (node && node !== container) {
+            info.x.targetOffset += node.offsetLeft;
+            info.y.targetOffset += node.offsetTop;
+            node = node.offsetParent;
+        }
+    }
+    info.x.targetLength =
+        target === container ? target.scrollWidth : target.clientWidth;
+    info.y.targetLength =
+        target === container ? target.scrollHeight : target.clientHeight;
+    info.x.containerLength = container.clientWidth;
+    info.y.containerLength = container.clientHeight;
+    /**
+     * In development mode ensure scroll containers aren't position: static as this makes
+     * it difficult to measure their relative positions.
+     */
+    if (process.env.NODE_ENV !== "production") {
+        if (container && target && target !== container) {
+            warnOnce(getComputedStyle(container).position !== "static", "Please ensure that the container has a non-static position, like 'relative', 'fixed', or 'absolute' to ensure scroll offset is calculated correctly.");
+        }
+    }
+}
+function createOnScrollHandler(element, onScroll, info, options = {}) {
+    return {
+        measure: (time) => {
+            measure(element, options.target, info);
+            updateScrollInfo(element, info, time);
+            if (options.offset || options.target) {
+                resolveOffsets(element, info, options);
+            }
+        },
+        notify: () => onScroll(info),
+    };
+}
+
+export { createOnScrollHandler };

node_modules/framer-motion/dist/es/render/dom/scroll/track.mjs

@@ -0,0 +1,80 @@
+import { resize, frame, cancelFrame, frameData } from 'motion-dom';
+import { noop } from 'motion-utils';
+import { createScrollInfo } from './info.mjs';
+import { createOnScrollHandler } from './on-scroll-handler.mjs';
+
+const scrollListeners = new WeakMap();
+const resizeListeners = new WeakMap();
+const onScrollHandlers = new WeakMap();
+const getEventTarget = (element) => element === document.scrollingElement ? window : element;
+function scrollInfo(onScroll, { container = document.scrollingElement, ...options } = {}) {
+    if (!container)
+        return noop;
+    let containerHandlers = onScrollHandlers.get(container);
+    /**
+     * Get the onScroll handlers for this container.
+     * If one isn't found, create a new one.
+     */
+    if (!containerHandlers) {
+        containerHandlers = new Set();
+        onScrollHandlers.set(container, containerHandlers);
+    }
+    /**
+     * Create a new onScroll handler for the provided callback.
+     */
+    const info = createScrollInfo();
+    const containerHandler = createOnScrollHandler(container, onScroll, info, options);
+    containerHandlers.add(containerHandler);
+    /**
+     * Check if there's a scroll event listener for this container.
+     * If not, create one.
+     */
+    if (!scrollListeners.has(container)) {
+        const measureAll = () => {
+            for (const handler of containerHandlers) {
+                handler.measure(frameData.timestamp);
+            }
+            frame.preUpdate(notifyAll);
+        };
+        const notifyAll = () => {
+            for (const handler of containerHandlers) {
+                handler.notify();
+            }
+        };
+        const listener = () => frame.read(measureAll);
+        scrollListeners.set(container, listener);
+        const target = getEventTarget(container);
+        window.addEventListener("resize", listener, { passive: true });
+        if (container !== document.documentElement) {
+            resizeListeners.set(container, resize(container, listener));
+        }
+        target.addEventListener("scroll", listener, { passive: true });
+        listener();
+    }
+    const listener = scrollListeners.get(container);
+    frame.read(listener, false, true);
+    return () => {
+        cancelFrame(listener);
+        /**
+         * Check if we even have any handlers for this container.
+         */
+        const currentHandlers = onScrollHandlers.get(container);
+        if (!currentHandlers)
+            return;
+        currentHandlers.delete(containerHandler);
+        if (currentHandlers.size)
+            return;
+        /**
+         * If no more handlers, remove the scroll listener too.
+         */
+        const scrollListener = scrollListeners.get(container);
+        scrollListeners.delete(container);
+        if (scrollListener) {
+            getEventTarget(container).removeEventListener("scroll", scrollListener);
+            resizeListeners.get(container)?.();
+            window.removeEventListener("resize", scrollListener);
+        }
+    };
+}
+
+export { scrollInfo };

node_modules/framer-motion/dist/es/render/dom/scroll/utils/get-timeline.mjs

@@ -0,0 +1,30 @@
+import { supportsScrollTimeline } from 'motion-dom';
+import { scrollInfo } from '../track.mjs';
+
+const timelineCache = new Map();
+function scrollTimelineFallback(options) {
+    const currentTime = { value: 0 };
+    const cancel = scrollInfo((info) => {
+        currentTime.value = info[options.axis].progress * 100;
+    }, options);
+    return { currentTime, cancel };
+}
+function getTimeline({ source, container, ...options }) {
+    const { axis } = options;
+    if (source)
+        container = source;
+    const containerCache = timelineCache.get(container) ?? new Map();
+    timelineCache.set(container, containerCache);
+    const targetKey = options.target ?? "self";
+    const targetCache = containerCache.get(targetKey) ?? {};
+    const axisKey = axis + (options.offset ?? []).join(",");
+    if (!targetCache[axisKey]) {
+        targetCache[axisKey] =
+            !options.target && supportsScrollTimeline()
+                ? new ScrollTimeline({ source: container, axis })
+                : scrollTimelineFallback({ container, ...options });
+    }
+    return targetCache[axisKey];
+}
+
+export { getTimeline };

node_modules/framer-motion/dist/es/render/dom/use-render.mjs

@@ -0,0 +1,29 @@
+"use client";
+import { isMotionValue } from 'motion-dom';
+import { Fragment, useMemo, createElement } from 'react';
+import { useHTMLProps } from '../html/use-props.mjs';
+import { useSVGProps } from '../svg/use-props.mjs';
+import { filterProps } from './utils/filter-props.mjs';
+import { isSVGComponent } from './utils/is-svg-component.mjs';
+
+function useRender(Component, props, ref, { latestValues, }, isStatic, forwardMotionProps = false) {
+    const useVisualProps = isSVGComponent(Component)
+        ? useSVGProps
+        : useHTMLProps;
+    const visualProps = useVisualProps(props, latestValues, isStatic, Component);
+    const filteredProps = filterProps(props, typeof Component === "string", forwardMotionProps);
+    const elementProps = Component !== Fragment ? { ...filteredProps, ...visualProps, ref } : {};
+    /**
+     * If component has been handed a motion value as its child,
+     * memoise its initial value and render that. Subsequent updates
+     * will be handled by the onChange handler
+     */
+    const { children } = props;
+    const renderedChildren = useMemo(() => (isMotionValue(children) ? children.get() : children), [children]);
+    return createElement(Component, {
+        ...elementProps,
+        children: renderedChildren,
+    });
+}
+
+export { useRender };

node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs

@@ -0,0 +1,6 @@
+/**
+ * Convert camelCase to dash-case properties.
+ */
+const camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase();
+
+export { camelToDash };

node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs

@@ -0,0 +1,59 @@
+import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';
+
+let shouldForward = (key) => !isValidMotionProp(key);
+function loadExternalIsValidProp(isValidProp) {
+    if (typeof isValidProp !== "function")
+        return;
+    // Explicitly filter our events
+    shouldForward = (key) => key.startsWith("on") ? !isValidMotionProp(key) : isValidProp(key);
+}
+/**
+ * Emotion and Styled Components both allow users to pass through arbitrary props to their components
+ * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which
+ * of these should be passed to the underlying DOM node.
+ *
+ * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props
+ * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props
+ * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of
+ * `@emotion/is-prop-valid`, however to fix this problem we need to use it.
+ *
+ * By making it an optionalDependency we can offer this functionality only in the situations where it's
+ * actually required.
+ */
+try {
+    /**
+     * We attempt to import this package but require won't be defined in esm environments, in that case
+     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed
+     * in favour of explicit injection.
+     */
+    loadExternalIsValidProp(require("@emotion/is-prop-valid").default);
+}
+catch {
+    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.
+}
+function filterProps(props, isDom, forwardMotionProps) {
+    const filteredProps = {};
+    for (const key in props) {
+        /**
+         * values is considered a valid prop by Emotion, so if it's present
+         * this will be rendered out to the DOM unless explicitly filtered.
+         *
+         * We check the type as it could be used with the `feColorMatrix`
+         * element, which we support.
+         */
+        if (key === "values" && typeof props.values === "object")
+            continue;
+        if (shouldForward(key) ||
+            (forwardMotionProps === true && isValidMotionProp(key)) ||
+            (!isDom && !isValidMotionProp(key)) ||
+            // If trying to use native HTML drag events, forward drag listeners
+            (props["draggable"] &&
+                key.startsWith("onDrag"))) {
+            filteredProps[key] =
+                props[key];
+        }
+    }
+    return filteredProps;
+}
+
+export { filterProps, loadExternalIsValidProp };

node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs

@@ -0,0 +1,30 @@
+import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';
+
+function isSVGComponent(Component) {
+    if (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof Component !== "string" ||
+        /**
+         * If it contains a dash, the element is a custom HTML webcomponent.
+         */
+        Component.includes("-")) {
+        return false;
+    }
+    else if (
+    /**
+     * If it's in our list of lowercase SVG tags, it's an SVG component
+     */
+    lowercaseSVGElements.indexOf(Component) > -1 ||
+        /**
+         * If it contains a capital letter, it's an SVG component
+         */
+        /[A-Z]/u.test(Component)) {
+        return true;
+    }
+    return false;
+}
+
+export { isSVGComponent };

node_modules/framer-motion/dist/es/render/dom/viewport/index.mjs

@@ -0,0 +1,43 @@
+import { resolveElements } from 'motion-dom';
+
+const thresholds = {
+    some: 0,
+    all: 1,
+};
+function inView(elementOrSelector, onStart, { root, margin: rootMargin, amount = "some" } = {}) {
+    const elements = resolveElements(elementOrSelector);
+    const activeIntersections = new WeakMap();
+    const onIntersectionChange = (entries) => {
+        entries.forEach((entry) => {
+            const onEnd = activeIntersections.get(entry.target);
+            /**
+             * If there's no change to the intersection, we don't need to
+             * do anything here.
+             */
+            if (entry.isIntersecting === Boolean(onEnd))
+                return;
+            if (entry.isIntersecting) {
+                const newOnEnd = onStart(entry.target, entry);
+                if (typeof newOnEnd === "function") {
+                    activeIntersections.set(entry.target, newOnEnd);
+                }
+                else {
+                    observer.unobserve(entry.target);
+                }
+            }
+            else if (typeof onEnd === "function") {
+                onEnd(entry);
+                activeIntersections.delete(entry.target);
+            }
+        });
+    };
+    const observer = new IntersectionObserver(onIntersectionChange, {
+        root,
+        rootMargin,
+        threshold: typeof amount === "number" ? amount : thresholds[amount],
+    });
+    elements.forEach((element) => observer.observe(element));
+    return () => observer.disconnect();
+}
+
+export { inView };

node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs

@@ -0,0 +1,42 @@
+import { transformProps, defaultTransformValue, readTransformValue, isCSSVariableName } from 'motion-dom';
+import { measureViewportBox } from '../../projection/utils/measure.mjs';
+import { DOMVisualElement } from '../dom/DOMVisualElement.mjs';
+import { buildHTMLStyles } from './utils/build-styles.mjs';
+import { renderHTML } from './utils/render.mjs';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';
+
+function getComputedStyle(element) {
+    return window.getComputedStyle(element);
+}
+class HTMLVisualElement extends DOMVisualElement {
+    constructor() {
+        super(...arguments);
+        this.type = "html";
+        this.renderInstance = renderHTML;
+    }
+    readValueFromInstance(instance, key) {
+        if (transformProps.has(key)) {
+            return this.projection?.isProjecting
+                ? defaultTransformValue(key)
+                : readTransformValue(instance, key);
+        }
+        else {
+            const computedStyle = getComputedStyle(instance);
+            const value = (isCSSVariableName(key)
+                ? computedStyle.getPropertyValue(key)
+                : computedStyle[key]) || 0;
+            return typeof value === "string" ? value.trim() : value;
+        }
+    }
+    measureInstanceViewportBox(instance, { transformPagePoint }) {
+        return measureViewportBox(instance, transformPagePoint);
+    }
+    build(renderState, latestValues, props) {
+        buildHTMLStyles(renderState, latestValues, props.transformTemplate);
+    }
+    scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+        return scrapeMotionValuesFromProps(props, prevProps, visualElement);
+    }
+}
+
+export { HTMLVisualElement, getComputedStyle };

node_modules/framer-motion/dist/es/render/html/use-html-visual-state.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';
+import { createHtmlRenderState } from './utils/create-render-state.mjs';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';
+
+const useHTMLVisualState = /*@__PURE__*/ makeUseVisualState({
+    scrapeMotionValuesFromProps,
+    createRenderState: createHtmlRenderState,
+});
+
+export { useHTMLVisualState };

node_modules/framer-motion/dist/es/render/html/use-props.mjs

@@ -0,0 +1,58 @@
+"use client";
+import { isMotionValue } from 'motion-dom';
+import { useMemo } from 'react';
+import { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.mjs';
+import { buildHTMLStyles } from './utils/build-styles.mjs';
+import { createHtmlRenderState } from './utils/create-render-state.mjs';
+
+function copyRawValuesOnly(target, source, props) {
+    for (const key in source) {
+        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {
+            target[key] = source[key];
+        }
+    }
+}
+function useInitialMotionValues({ transformTemplate }, visualState) {
+    return useMemo(() => {
+        const state = createHtmlRenderState();
+        buildHTMLStyles(state, visualState, transformTemplate);
+        return Object.assign({}, state.vars, state.style);
+    }, [visualState]);
+}
+function useStyle(props, visualState) {
+    const styleProp = props.style || {};
+    const style = {};
+    /**
+     * Copy non-Motion Values straight into style
+     */
+    copyRawValuesOnly(style, styleProp, props);
+    Object.assign(style, useInitialMotionValues(props, visualState));
+    return style;
+}
+function useHTMLProps(props, visualState) {
+    // The `any` isn't ideal but it is the type of createElement props argument
+    const htmlProps = {};
+    const style = useStyle(props, visualState);
+    if (props.drag && props.dragListener !== false) {
+        // Disable the ghost element when a user drags
+        htmlProps.draggable = false;
+        // Disable text selection
+        style.userSelect =
+            style.WebkitUserSelect =
+                style.WebkitTouchCallout =
+                    "none";
+        // Disable scrolling on the draggable direction
+        style.touchAction =
+            props.drag === true
+                ? "none"
+                : `pan-${props.drag === "x" ? "y" : "x"}`;
+    }
+    if (props.tabIndex === undefined &&
+        (props.onTap || props.onTapStart || props.whileTap)) {
+        htmlProps.tabIndex = 0;
+    }
+    htmlProps.style = style;
+    return htmlProps;
+}
+
+export { copyRawValuesOnly, useHTMLProps };

node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs

@@ -0,0 +1,62 @@
+import { transformProps, isCSSVariableName, getValueAsType, numberValueTypes } from 'motion-dom';
+import { buildTransform } from './build-transform.mjs';
+
+function buildHTMLStyles(state, latestValues, transformTemplate) {
+    const { style, vars, transformOrigin } = state;
+    // Track whether we encounter any transform or transformOrigin values.
+    let hasTransform = false;
+    let hasTransformOrigin = false;
+    /**
+     * Loop over all our latest animated values and decide whether to handle them
+     * as a style or CSS variable.
+     *
+     * Transforms and transform origins are kept separately for further processing.
+     */
+    for (const key in latestValues) {
+        const value = latestValues[key];
+        if (transformProps.has(key)) {
+            // If this is a transform, flag to enable further transform processing
+            hasTransform = true;
+            continue;
+        }
+        else if (isCSSVariableName(key)) {
+            vars[key] = value;
+            continue;
+        }
+        else {
+            // Convert the value to its default value type, ie 0 -> "0px"
+            const valueAsType = getValueAsType(value, numberValueTypes[key]);
+            if (key.startsWith("origin")) {
+                // If this is a transform origin, flag and enable further transform-origin processing
+                hasTransformOrigin = true;
+                transformOrigin[key] =
+                    valueAsType;
+            }
+            else {
+                style[key] = valueAsType;
+            }
+        }
+    }
+    if (!latestValues.transform) {
+        if (hasTransform || transformTemplate) {
+            style.transform = buildTransform(latestValues, state.transform, transformTemplate);
+        }
+        else if (style.transform) {
+            /**
+             * If we have previously created a transform but currently don't have any,
+             * reset transform style to none.
+             */
+            style.transform = "none";
+        }
+    }
+    /**
+     * Build a transformOrigin style. Uses the same defaults as the browser for
+     * undefined origins.
+     */
+    if (hasTransformOrigin) {
+        const { originX = "50%", originY = "50%", originZ = 0, } = transformOrigin;
+        style.transformOrigin = `${originX} ${originY} ${originZ}`;
+    }
+}
+
+export { buildHTMLStyles };

node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs

@@ -0,0 +1,60 @@
+import { transformPropOrder, getValueAsType, numberValueTypes } from 'motion-dom';
+
+const translateAlias = {
+    x: "translateX",
+    y: "translateY",
+    z: "translateZ",
+    transformPerspective: "perspective",
+};
+const numTransforms = transformPropOrder.length;
+/**
+ * Build a CSS transform style from individual x/y/scale etc properties.
+ *
+ * This outputs with a default order of transforms/scales/rotations, this can be customised by
+ * providing a transformTemplate function.
+ */
+function buildTransform(latestValues, transform, transformTemplate) {
+    // The transform string we're going to build into.
+    let transformString = "";
+    let transformIsDefault = true;
+    /**
+     * Loop over all possible transforms in order, adding the ones that
+     * are present to the transform string.
+     */
+    for (let i = 0; i < numTransforms; i++) {
+        const key = transformPropOrder[i];
+        const value = latestValues[key];
+        if (value === undefined)
+            continue;
+        let valueIsDefault = true;
+        if (typeof value === "number") {
+            valueIsDefault = value === (key.startsWith("scale") ? 1 : 0);
+        }
+        else {
+            valueIsDefault = parseFloat(value) === 0;
+        }
+        if (!valueIsDefault || transformTemplate) {
+            const valueAsType = getValueAsType(value, numberValueTypes[key]);
+            if (!valueIsDefault) {
+                transformIsDefault = false;
+                const transformName = translateAlias[key] || key;
+                transformString += `${transformName}(${valueAsType}) `;
+            }
+            if (transformTemplate) {
+                transform[key] = valueAsType;
+            }
+        }
+    }
+    transformString = transformString.trim();
+    // If we have a custom `transform` template, pass our transform values and
+    // generated transformString to that before returning
+    if (transformTemplate) {
+        transformString = transformTemplate(transform, transformIsDefault ? "" : transformString);
+    }
+    else if (transformIsDefault) {
+        transformString = "none";
+    }
+    return transformString;
+}
+
+export { buildTransform };

node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs

@@ -0,0 +1,8 @@
+const createHtmlRenderState = () => ({
+    style: {},
+    transform: {},
+    transformOrigin: {},
+    vars: {},
+});
+
+export { createHtmlRenderState };

node_modules/framer-motion/dist/es/render/html/utils/render.mjs

@@ -0,0 +1,17 @@
+function renderHTML(element, { style, vars }, styleProp, projection) {
+    const elementStyle = element.style;
+    let key;
+    for (key in style) {
+        // CSSStyleDeclaration has [index: number]: string; in the types, so we use that as key type.
+        elementStyle[key] = style[key];
+    }
+    // Write projection styles directly to element style
+    projection?.applyProjectionStyles(elementStyle, styleProp);
+    for (key in vars) {
+        // Loop over any CSS variables and assign those.
+        // They can only be assigned using `setProperty`.
+        elementStyle.setProperty(key, vars[key]);
+    }
+}
+
+export { renderHTML };

node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs

@@ -0,0 +1,19 @@
+import { isMotionValue } from 'motion-dom';
+import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';
+
+function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+    const { style } = props;
+    const newValues = {};
+    for (const key in style) {
+        if (isMotionValue(style[key]) ||
+            (prevProps.style &&
+                isMotionValue(prevProps.style[key])) ||
+            isForcedMotionValue(key, props) ||
+            visualElement?.getValue(key)?.liveStyle !== undefined) {
+            newValues[key] = style[key];
+        }
+    }
+    return newValues;
+}
+
+export { scrapeMotionValuesFromProps };

node_modules/framer-motion/dist/es/render/object/ObjectVisualElement.mjs

@@ -0,0 +1,41 @@
+import { createBox } from '../../projection/geometry/models.mjs';
+import { VisualElement } from '../VisualElement.mjs';
+
+function isObjectKey(key, object) {
+    return key in object;
+}
+class ObjectVisualElement extends VisualElement {
+    constructor() {
+        super(...arguments);
+        this.type = "object";
+    }
+    readValueFromInstance(instance, key) {
+        if (isObjectKey(key, instance)) {
+            const value = instance[key];
+            if (typeof value === "string" || typeof value === "number") {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    getBaseTargetFromProps() {
+        return undefined;
+    }
+    removeValueFromRenderState(key, renderState) {
+        delete renderState.output[key];
+    }
+    measureInstanceViewportBox() {
+        return createBox();
+    }
+    build(renderState, latestValues) {
+        Object.assign(renderState.output, latestValues);
+    }
+    renderInstance(instance, { output }) {
+        Object.assign(instance, output);
+    }
+    sortInstanceNodePosition() {
+        return 0;
+    }
+}
+
+export { ObjectVisualElement };

node_modules/framer-motion/dist/es/render/store.mjs

@@ -0,0 +1,3 @@
+const visualElementStore = new WeakMap();
+
+export { visualElementStore };

node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs

@@ -0,0 +1,44 @@
+import { transformProps, getDefaultValueType } from 'motion-dom';
+import { createBox } from '../../projection/geometry/models.mjs';
+import { DOMVisualElement } from '../dom/DOMVisualElement.mjs';
+import { camelToDash } from '../dom/utils/camel-to-dash.mjs';
+import { buildSVGAttrs } from './utils/build-attrs.mjs';
+import { camelCaseAttributes } from './utils/camel-case-attrs.mjs';
+import { isSVGTag } from './utils/is-svg-tag.mjs';
+import { renderSVG } from './utils/render.mjs';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';
+
+class SVGVisualElement extends DOMVisualElement {
+    constructor() {
+        super(...arguments);
+        this.type = "svg";
+        this.isSVGTag = false;
+        this.measureInstanceViewportBox = createBox;
+    }
+    getBaseTargetFromProps(props, key) {
+        return props[key];
+    }
+    readValueFromInstance(instance, key) {
+        if (transformProps.has(key)) {
+            const defaultType = getDefaultValueType(key);
+            return defaultType ? defaultType.default || 0 : 0;
+        }
+        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
+        return instance.getAttribute(key);
+    }
+    scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+        return scrapeMotionValuesFromProps(props, prevProps, visualElement);
+    }
+    build(renderState, latestValues, props) {
+        buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate, props.style);
+    }
+    renderInstance(instance, renderState, styleProp, projection) {
+        renderSVG(instance, renderState, styleProp, projection);
+    }
+    mount(instance) {
+        this.isSVGTag = isSVGTag(instance.tagName);
+        super.mount(instance);
+    }
+}
+
+export { SVGVisualElement };

node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs

@@ -0,0 +1,33 @@
+/**
+ * We keep these listed separately as we use the lowercase tag names as part
+ * of the runtime bundle to detect SVG components
+ */
+const lowercaseSVGElements = [
+    "animate",
+    "circle",
+    "defs",
+    "desc",
+    "ellipse",
+    "g",
+    "image",
+    "line",
+    "filter",
+    "marker",
+    "mask",
+    "metadata",
+    "path",
+    "pattern",
+    "polygon",
+    "polyline",
+    "rect",
+    "stop",
+    "switch",
+    "symbol",
+    "svg",
+    "text",
+    "tspan",
+    "use",
+    "view",
+];
+
+export { lowercaseSVGElements };

node_modules/framer-motion/dist/es/render/svg/use-props.mjs

@@ -0,0 +1,25 @@
+"use client";
+import { useMemo } from 'react';
+import { copyRawValuesOnly } from '../html/use-props.mjs';
+import { buildSVGAttrs } from './utils/build-attrs.mjs';
+import { createSvgRenderState } from './utils/create-render-state.mjs';
+import { isSVGTag } from './utils/is-svg-tag.mjs';
+
+function useSVGProps(props, visualState, _isStatic, Component) {
+    const visualProps = useMemo(() => {
+        const state = createSvgRenderState();
+        buildSVGAttrs(state, visualState, isSVGTag(Component), props.transformTemplate, props.style);
+        return {
+            ...state.attrs,
+            style: { ...state.style },
+        };
+    }, [visualState]);
+    if (props.style) {
+        const rawStyles = {};
+        copyRawValuesOnly(rawStyles, props.style, props);
+        visualProps.style = { ...rawStyles, ...visualProps.style };
+    }
+    return visualProps;
+}
+
+export { useSVGProps };

node_modules/framer-motion/dist/es/render/svg/use-svg-visual-state.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';
+import { createSvgRenderState } from './utils/create-render-state.mjs';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';
+
+const useSVGVisualState = /*@__PURE__*/ makeUseVisualState({
+    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,
+    createRenderState: createSvgRenderState,
+});
+
+export { useSVGVisualState };

node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs

@@ -0,0 +1,57 @@
+import { buildHTMLStyles } from '../../html/utils/build-styles.mjs';
+import { buildSVGPath } from './path.mjs';
+
+/**
+ * Build SVG visual attributes, like cx and style.transform
+ */
+function buildSVGAttrs(state, { attrX, attrY, attrScale, pathLength, pathSpacing = 1, pathOffset = 0, 
+// This is object creation, which we try to avoid per-frame.
+...latest }, isSVGTag, transformTemplate, styleProp) {
+    buildHTMLStyles(state, latest, transformTemplate);
+    /**
+     * For svg tags we just want to make sure viewBox is animatable and treat all the styles
+     * as normal HTML tags.
+     */
+    if (isSVGTag) {
+        if (state.style.viewBox) {
+            state.attrs.viewBox = state.style.viewBox;
+        }
+        return;
+    }
+    state.attrs = state.style;
+    state.style = {};
+    const { attrs, style } = state;
+    /**
+     * However, we apply transforms as CSS transforms.
+     * So if we detect a transform, transformOrigin we take it from attrs and copy it into style.
+     */
+    if (attrs.transform) {
+        style.transform = attrs.transform;
+        delete attrs.transform;
+    }
+    if (style.transform || attrs.transformOrigin) {
+        style.transformOrigin = attrs.transformOrigin ?? "50% 50%";
+        delete attrs.transformOrigin;
+    }
+    if (style.transform) {
+        /**
+         * SVG's element transform-origin uses its own median as a reference.
+         * Therefore, transformBox becomes a fill-box
+         */
+        style.transformBox = styleProp?.transformBox ?? "fill-box";
+        delete attrs.transformBox;
+    }
+    // Render attrX/attrY/attrScale as attributes
+    if (attrX !== undefined)
+        attrs.x = attrX;
+    if (attrY !== undefined)
+        attrs.y = attrY;
+    if (attrScale !== undefined)
+        attrs.scale = attrScale;
+    // Build SVG path if one has been defined
+    if (pathLength !== undefined) {
+        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
+    }
+}
+
+export { buildSVGAttrs };

node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs

@@ -0,0 +1,30 @@
+/**
+ * A set of attribute names that are always read/written as camel case.
+ */
+const camelCaseAttributes = new Set([
+    "baseFrequency",
+    "diffuseConstant",
+    "kernelMatrix",
+    "kernelUnitLength",
+    "keySplines",
+    "keyTimes",
+    "limitingConeAngle",
+    "markerHeight",
+    "markerWidth",
+    "numOctaves",
+    "targetX",
+    "targetY",
+    "surfaceScale",
+    "specularConstant",
+    "specularExponent",
+    "stdDeviation",
+    "tableValues",
+    "viewBox",
+    "gradientTransform",
+    "pathLength",
+    "startOffset",
+    "textLength",
+    "lengthAdjust",
+]);
+
+export { camelCaseAttributes };

node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs

@@ -0,0 +1,8 @@
+import { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';
+
+const createSvgRenderState = () => ({
+    ...createHtmlRenderState(),
+    attrs: {},
+});
+
+export { createSvgRenderState };

node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs

@@ -0,0 +1,3 @@
+const isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
+
+export { isSVGTag };

node_modules/framer-motion/dist/es/render/svg/utils/path.mjs

@@ -0,0 +1,32 @@
+import { px } from 'motion-dom';
+
+const dashKeys = {
+    offset: "stroke-dashoffset",
+    array: "stroke-dasharray",
+};
+const camelKeys = {
+    offset: "strokeDashoffset",
+    array: "strokeDasharray",
+};
+/**
+ * Build SVG path properties. Uses the path's measured length to convert
+ * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset
+ * and stroke-dasharray attributes.
+ *
+ * This function is mutative to reduce per-frame GC.
+ */
+function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
+    // Normalise path length by setting SVG attribute pathLength to 1
+    attrs.pathLength = 1;
+    // We use dash case when setting attributes directly to the DOM node and camel case
+    // when defining props on a React component.
+    const keys = useDashCase ? dashKeys : camelKeys;
+    // Build the dash offset
+    attrs[keys.offset] = px.transform(-offset);
+    // Build the dash array
+    const pathLength = px.transform(length);
+    const pathSpacing = px.transform(spacing);
+    attrs[keys.array] = `${pathLength} ${pathSpacing}`;
+}
+
+export { buildSVGPath };

node_modules/framer-motion/dist/es/render/svg/utils/render.mjs

@@ -0,0 +1,12 @@
+import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';
+import { renderHTML } from '../../html/utils/render.mjs';
+import { camelCaseAttributes } from './camel-case-attrs.mjs';
+
+function renderSVG(element, renderState, _styleProp, projection) {
+    renderHTML(element, renderState, undefined, projection);
+    for (const key in renderState.attrs) {
+        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
+    }
+}
+
+export { renderSVG };

node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs

@@ -0,0 +1,18 @@
+import { isMotionValue, transformPropOrder } from 'motion-dom';
+import { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';
+
+function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+    const newValues = scrapeMotionValuesFromProps$1(props, prevProps, visualElement);
+    for (const key in props) {
+        if (isMotionValue(props[key]) ||
+            isMotionValue(prevProps[key])) {
+            const targetKey = transformPropOrder.indexOf(key) !== -1
+                ? "attr" + key.charAt(0).toUpperCase() + key.substring(1)
+                : key;
+            newValues[targetKey] = props[key];
+        }
+    }
+    return newValues;
+}
+
+export { scrapeMotionValuesFromProps };

node_modules/framer-motion/dist/es/render/utils/animation-state.mjs

@@ -0,0 +1,362 @@
+import { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';
+import { calcChildStagger } from '../../animation/utils/calc-child-stagger.mjs';
+import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';
+import { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';
+import { shallowCompare } from '../../utils/shallow-compare.mjs';
+import { getVariantContext } from './get-variant-context.mjs';
+import { isVariantLabel } from './is-variant-label.mjs';
+import { resolveVariant } from './resolve-dynamic-variants.mjs';
+import { variantPriorityOrder } from './variant-props.mjs';
+
+const reversePriorityOrder = [...variantPriorityOrder].reverse();
+const numAnimationTypes = variantPriorityOrder.length;
+function animateList(visualElement) {
+    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
+}
+function createAnimationState(visualElement) {
+    let animate = animateList(visualElement);
+    let state = createState();
+    let isInitialRender = true;
+    /**
+     * This function will be used to reduce the animation definitions for
+     * each active animation type into an object of resolved values for it.
+     */
+    const buildResolvedTypeValues = (type) => (acc, definition) => {
+        const resolved = resolveVariant(visualElement, definition, type === "exit"
+            ? visualElement.presenceContext?.custom
+            : undefined);
+        if (resolved) {
+            const { transition, transitionEnd, ...target } = resolved;
+            acc = { ...acc, ...target, ...transitionEnd };
+        }
+        return acc;
+    };
+    /**
+     * This just allows us to inject mocked animation functions
+     * @internal
+     */
+    function setAnimateFunction(makeAnimator) {
+        animate = makeAnimator(visualElement);
+    }
+    /**
+     * When we receive new props, we need to:
+     * 1. Create a list of protected keys for each type. This is a directory of
+     *    value keys that are currently being "handled" by types of a higher priority
+     *    so that whenever an animation is played of a given type, these values are
+     *    protected from being animated.
+     * 2. Determine if an animation type needs animating.
+     * 3. Determine if any values have been removed from a type and figure out
+     *    what to animate those to.
+     */
+    function animateChanges(changedActiveType) {
+        const { props } = visualElement;
+        const context = getVariantContext(visualElement.parent) || {};
+        /**
+         * A list of animations that we'll build into as we iterate through the animation
+         * types. This will get executed at the end of the function.
+         */
+        const animations = [];
+        /**
+         * Keep track of which values have been removed. Then, as we hit lower priority
+         * animation types, we can check if they contain removed values and animate to that.
+         */
+        const removedKeys = new Set();
+        /**
+         * A dictionary of all encountered keys. This is an object to let us build into and
+         * copy it without iteration. Each time we hit an animation type we set its protected
+         * keys - the keys its not allowed to animate - to the latest version of this object.
+         */
+        let encounteredKeys = {};
+        /**
+         * If a variant has been removed at a given index, and this component is controlling
+         * variant animations, we want to ensure lower-priority variants are forced to animate.
+         */
+        let removedVariantIndex = Infinity;
+        /**
+         * Iterate through all animation types in reverse priority order. For each, we want to
+         * detect which values it's handling and whether or not they've changed (and therefore
+         * need to be animated). If any values have been removed, we want to detect those in
+         * lower priority props and flag for animation.
+         */
+        for (let i = 0; i < numAnimationTypes; i++) {
+            const type = reversePriorityOrder[i];
+            const typeState = state[type];
+            const prop = props[type] !== undefined
+                ? props[type]
+                : context[type];
+            const propIsVariant = isVariantLabel(prop);
+            /**
+             * If this type has *just* changed isActive status, set activeDelta
+             * to that status. Otherwise set to null.
+             */
+            const activeDelta = type === changedActiveType ? typeState.isActive : null;
+            if (activeDelta === false)
+                removedVariantIndex = i;
+            /**
+             * If this prop is an inherited variant, rather than been set directly on the
+             * component itself, we want to make sure we allow the parent to trigger animations.
+             *
+             * TODO: Can probably change this to a !isControllingVariants check
+             */
+            let isInherited = prop === context[type] &&
+                prop !== props[type] &&
+                propIsVariant;
+            if (isInherited &&
+                isInitialRender &&
+                visualElement.manuallyAnimateOnMount) {
+                isInherited = false;
+            }
+            /**
+             * Set all encountered keys so far as the protected keys for this type. This will
+             * be any key that has been animated or otherwise handled by active, higher-priortiy types.
+             */
+            typeState.protectedKeys = { ...encounteredKeys };
+            // Check if we can skip analysing this prop early
+            if (
+            // If it isn't active and hasn't *just* been set as inactive
+            (!typeState.isActive && activeDelta === null) ||
+                // If we didn't and don't have any defined prop for this animation type
+                (!prop && !typeState.prevProp) ||
+                // Or if the prop doesn't define an animation
+                isAnimationControls(prop) ||
+                typeof prop === "boolean") {
+                continue;
+            }
+            /**
+             * As we go look through the values defined on this type, if we detect
+             * a changed value or a value that was removed in a higher priority, we set
+             * this to true and add this prop to the animation list.
+             */
+            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
+            let shouldAnimateType = variantDidChange ||
+                // If we're making this variant active, we want to always make it active
+                (type === changedActiveType &&
+                    typeState.isActive &&
+                    !isInherited &&
+                    propIsVariant) ||
+                // If we removed a higher-priority variant (i is in reverse order)
+                (i > removedVariantIndex && propIsVariant);
+            let handledRemovedValues = false;
+            /**
+             * As animations can be set as variant lists, variants or target objects, we
+             * coerce everything to an array if it isn't one already
+             */
+            const definitionList = Array.isArray(prop) ? prop : [prop];
+            /**
+             * Build an object of all the resolved values. We'll use this in the subsequent
+             * animateChanges calls to determine whether a value has changed.
+             */
+            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
+            if (activeDelta === false)
+                resolvedValues = {};
+            /**
+             * Now we need to loop through all the keys in the prev prop and this prop,
+             * and decide:
+             * 1. If the value has changed, and needs animating
+             * 2. If it has been removed, and needs adding to the removedKeys set
+             * 3. If it has been removed in a higher priority type and needs animating
+             * 4. If it hasn't been removed in a higher priority but hasn't changed, and
+             *    needs adding to the type's protectedKeys list.
+             */
+            const { prevResolvedValues = {} } = typeState;
+            const allKeys = {
+                ...prevResolvedValues,
+                ...resolvedValues,
+            };
+            const markToAnimate = (key) => {
+                shouldAnimateType = true;
+                if (removedKeys.has(key)) {
+                    handledRemovedValues = true;
+                    removedKeys.delete(key);
+                }
+                typeState.needsAnimating[key] = true;
+                const motionValue = visualElement.getValue(key);
+                if (motionValue)
+                    motionValue.liveStyle = false;
+            };
+            for (const key in allKeys) {
+                const next = resolvedValues[key];
+                const prev = prevResolvedValues[key];
+                // If we've already handled this we can just skip ahead
+                if (encounteredKeys.hasOwnProperty(key))
+                    continue;
+                /**
+                 * If the value has changed, we probably want to animate it.
+                 */
+                let valueHasChanged = false;
+                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {
+                    valueHasChanged = !shallowCompare(next, prev);
+                }
+                else {
+                    valueHasChanged = next !== prev;
+                }
+                if (valueHasChanged) {
+                    if (next !== undefined && next !== null) {
+                        // If next is defined and doesn't equal prev, it needs animating
+                        markToAnimate(key);
+                    }
+                    else {
+                        // If it's undefined, it's been removed.
+                        removedKeys.add(key);
+                    }
+                }
+                else if (next !== undefined && removedKeys.has(key)) {
+                    /**
+                     * If next hasn't changed and it isn't undefined, we want to check if it's
+                     * been removed by a higher priority
+                     */
+                    markToAnimate(key);
+                }
+                else {
+                    /**
+                     * If it hasn't changed, we add it to the list of protected values
+                     * to ensure it doesn't get animated.
+                     */
+                    typeState.protectedKeys[key] = true;
+                }
+            }
+            /**
+             * Update the typeState so next time animateChanges is called we can compare the
+             * latest prop and resolvedValues to these.
+             */
+            typeState.prevProp = prop;
+            typeState.prevResolvedValues = resolvedValues;
+            if (typeState.isActive) {
+                encounteredKeys = { ...encounteredKeys, ...resolvedValues };
+            }
+            if (isInitialRender && visualElement.blockInitialAnimation) {
+                shouldAnimateType = false;
+            }
+            /**
+             * If this is an inherited prop we want to skip this animation
+             * unless the inherited variants haven't changed on this render.
+             */
+            const willAnimateViaParent = isInherited && variantDidChange;
+            const needsAnimating = !willAnimateViaParent || handledRemovedValues;
+            if (shouldAnimateType && needsAnimating) {
+                animations.push(...definitionList.map((animation) => {
+                    const options = { type };
+                    /**
+                     * If we're performing the initial animation, but we're not
+                     * rendering at the same time as the variant-controlling parent,
+                     * we want to use the parent's transition to calculate the stagger.
+                     */
+                    if (typeof animation === "string" &&
+                        isInitialRender &&
+                        !willAnimateViaParent &&
+                        visualElement.manuallyAnimateOnMount &&
+                        visualElement.parent) {
+                        const { parent } = visualElement;
+                        const parentVariant = resolveVariant(parent, animation);
+                        if (parent.enteringChildren && parentVariant) {
+                            const { delayChildren } = parentVariant.transition || {};
+                            options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);
+                        }
+                    }
+                    return {
+                        animation: animation,
+                        options,
+                    };
+                }));
+            }
+        }
+        /**
+         * If there are some removed value that haven't been dealt with,
+         * we need to create a new animation that falls back either to the value
+         * defined in the style prop, or the last read value.
+         */
+        if (removedKeys.size) {
+            const fallbackAnimation = {};
+            /**
+             * If the initial prop contains a transition we can use that, otherwise
+             * allow the animation function to use the visual element's default.
+             */
+            if (typeof props.initial !== "boolean") {
+                const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial)
+                    ? props.initial[0]
+                    : props.initial);
+                if (initialTransition && initialTransition.transition) {
+                    fallbackAnimation.transition = initialTransition.transition;
+                }
+            }
+            removedKeys.forEach((key) => {
+                const fallbackTarget = visualElement.getBaseTarget(key);
+                const motionValue = visualElement.getValue(key);
+                if (motionValue)
+                    motionValue.liveStyle = true;
+                // @ts-expect-error - @mattgperry to figure if we should do something here
+                fallbackAnimation[key] = fallbackTarget ?? null;
+            });
+            animations.push({ animation: fallbackAnimation });
+        }
+        let shouldAnimate = Boolean(animations.length);
+        if (isInitialRender &&
+            (props.initial === false || props.initial === props.animate) &&
+            !visualElement.manuallyAnimateOnMount) {
+            shouldAnimate = false;
+        }
+        isInitialRender = false;
+        return shouldAnimate ? animate(animations) : Promise.resolve();
+    }
+    /**
+     * Change whether a certain animation type is active.
+     */
+    function setActive(type, isActive) {
+        // If the active state hasn't changed, we can safely do nothing here
+        if (state[type].isActive === isActive)
+            return Promise.resolve();
+        // Propagate active change to children
+        visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));
+        state[type].isActive = isActive;
+        const animations = animateChanges(type);
+        for (const key in state) {
+            state[key].protectedKeys = {};
+        }
+        return animations;
+    }
+    return {
+        animateChanges,
+        setActive,
+        setAnimateFunction,
+        getState: () => state,
+        reset: () => {
+            state = createState();
+            /**
+             * Temporarily disabling resetting this flag as it prevents components
+             * with initial={false} from animating after being remounted, for instance
+             * as the child of an Activity component.
+             */
+            // isInitialRender = true
+        },
+    };
+}
+function checkVariantsDidChange(prev, next) {
+    if (typeof next === "string") {
+        return next !== prev;
+    }
+    else if (Array.isArray(next)) {
+        return !shallowCompare(next, prev);
+    }
+    return false;
+}
+function createTypeState(isActive = false) {
+    return {
+        isActive,
+        protectedKeys: {},
+        needsAnimating: {},
+        prevResolvedValues: {},
+    };
+}
+function createState() {
+    return {
+        animate: createTypeState(true),
+        whileInView: createTypeState(),
+        whileHover: createTypeState(),
+        whileTap: createTypeState(),
+        whileDrag: createTypeState(),
+        whileFocus: createTypeState(),
+        exit: createTypeState(),
+    };
+}
+
+export { checkVariantsDidChange, createAnimationState };

node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs

@@ -0,0 +1,3 @@
+const compareByDepth = (a, b) => a.depth - b.depth;
+
+export { compareByDepth };

node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs

@@ -0,0 +1,24 @@
+import { addUniqueItem, removeItem } from 'motion-utils';
+import { compareByDepth } from './compare-by-depth.mjs';
+
+class FlatTree {
+    constructor() {
+        this.children = [];
+        this.isDirty = false;
+    }
+    add(child) {
+        addUniqueItem(this.children, child);
+        this.isDirty = true;
+    }
+    remove(child) {
+        removeItem(this.children, child);
+        this.isDirty = true;
+    }
+    forEach(callback) {
+        this.isDirty && this.children.sort(compareByDepth);
+        this.isDirty = false;
+        this.children.forEach(callback);
+    }
+}
+
+export { FlatTree };

node_modules/framer-motion/dist/es/render/utils/get-variant-context.mjs

@@ -0,0 +1,28 @@
+import { isVariantLabel } from './is-variant-label.mjs';
+import { variantProps } from './variant-props.mjs';
+
+const numVariantProps = variantProps.length;
+function getVariantContext(visualElement) {
+    if (!visualElement)
+        return undefined;
+    if (!visualElement.isControllingVariants) {
+        const context = visualElement.parent
+            ? getVariantContext(visualElement.parent) || {}
+            : {};
+        if (visualElement.props.initial !== undefined) {
+            context.initial = visualElement.props.initial;
+        }
+        return context;
+    }
+    const context = {};
+    for (let i = 0; i < numVariantProps; i++) {
+        const name = variantProps[i];
+        const prop = visualElement.props[name];
+        if (isVariantLabel(prop) || prop === false) {
+            context[name] = prop;
+        }
+    }
+    return context;
+}
+
+export { getVariantContext };

node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.mjs

@@ -0,0 +1,13 @@
+import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';
+import { isVariantLabel } from './is-variant-label.mjs';
+import { variantProps } from './variant-props.mjs';
+
+function isControllingVariants(props) {
+    return (isAnimationControls(props.animate) ||
+        variantProps.some((name) => isVariantLabel(props[name])));
+}
+function isVariantNode(props) {
+    return Boolean(isControllingVariants(props) || props.variants);
+}
+
+export { isControllingVariants, isVariantNode };

node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs

@@ -0,0 +1,8 @@
+/**
+ * Decides if the supplied variable is variant label
+ */
+function isVariantLabel(v) {
+    return typeof v === "string" || Array.isArray(v);
+}
+
+export { isVariantLabel };

node_modules/framer-motion/dist/es/render/utils/motion-values.mjs

@@ -0,0 +1,50 @@
+import { isMotionValue, motionValue } from 'motion-dom';
+
+function updateMotionValuesFromProps(element, next, prev) {
+    for (const key in next) {
+        const nextValue = next[key];
+        const prevValue = prev[key];
+        if (isMotionValue(nextValue)) {
+            /**
+             * If this is a motion value found in props or style, we want to add it
+             * to our visual element's motion value map.
+             */
+            element.addValue(key, nextValue);
+        }
+        else if (isMotionValue(prevValue)) {
+            /**
+             * If we're swapping from a motion value to a static value,
+             * create a new motion value from that
+             */
+            element.addValue(key, motionValue(nextValue, { owner: element }));
+        }
+        else if (prevValue !== nextValue) {
+            /**
+             * If this is a flat value that has changed, update the motion value
+             * or create one if it doesn't exist. We only want to do this if we're
+             * not handling the value with our animation state.
+             */
+            if (element.hasValue(key)) {
+                const existingValue = element.getValue(key);
+                if (existingValue.liveStyle === true) {
+                    existingValue.jump(nextValue);
+                }
+                else if (!existingValue.hasAnimated) {
+                    existingValue.set(nextValue);
+                }
+            }
+            else {
+                const latestValue = element.getStaticValue(key);
+                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));
+            }
+        }
+    }
+    // Handle removed values
+    for (const key in prev) {
+        if (next[key] === undefined)
+            element.removeValue(key);
+    }
+    return next;
+}
+
+export { updateMotionValuesFromProps };

node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs

@@ -0,0 +1,8 @@
+import { resolveVariantFromProps } from './resolve-variants.mjs';
+
+function resolveVariant(visualElement, definition, custom) {
+    const props = visualElement.getProps();
+    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);
+}
+
+export { resolveVariant };

node_modules/framer-motion/dist/es/render/utils/resolve-variants.mjs

@@ -0,0 +1,36 @@
+function getValueState(visualElement) {
+    const state = [{}, {}];
+    visualElement?.values.forEach((value, key) => {
+        state[0][key] = value.get();
+        state[1][key] = value.getVelocity();
+    });
+    return state;
+}
+function resolveVariantFromProps(props, definition, custom, visualElement) {
+    /**
+     * If the variant definition is a function, resolve.
+     */
+    if (typeof definition === "function") {
+        const [current, velocity] = getValueState(visualElement);
+        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);
+    }
+    /**
+     * If the variant definition is a variant label, or
+     * the function returned a variant label, resolve.
+     */
+    if (typeof definition === "string") {
+        definition = props.variants && props.variants[definition];
+    }
+    /**
+     * At this point we've resolved both functions and variant labels,
+     * but the resolved variant label might itself have been a function.
+     * If so, resolve. This can only have returned a valid target object.
+     */
+    if (typeof definition === "function") {
+        const [current, velocity] = getValueState(visualElement);
+        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);
+    }
+    return definition;
+}
+
+export { resolveVariantFromProps };

node_modules/framer-motion/dist/es/render/utils/setters.mjs

@@ -0,0 +1,31 @@
+import { motionValue } from 'motion-dom';
+import { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';
+import { resolveVariant } from './resolve-dynamic-variants.mjs';
+
+/**
+ * Set VisualElement's MotionValue, creating a new MotionValue for it if
+ * it doesn't exist.
+ */
+function setMotionValue(visualElement, key, value) {
+    if (visualElement.hasValue(key)) {
+        visualElement.getValue(key).set(value);
+    }
+    else {
+        visualElement.addValue(key, motionValue(value));
+    }
+}
+function resolveFinalValueInKeyframes(v) {
+    // TODO maybe throw if v.length - 1 is placeholder token?
+    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
+}
+function setTarget(visualElement, definition) {
+    const resolved = resolveVariant(visualElement, definition);
+    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
+    target = { ...target, ...transitionEnd };
+    for (const key in target) {
+        const value = resolveFinalValueInKeyframes(target[key]);
+        setMotionValue(visualElement, key, value);
+    }
+}
+
+export { setTarget };

node_modules/framer-motion/dist/es/render/utils/variant-props.mjs

@@ -0,0 +1,12 @@
+const variantPriorityOrder = [
+    "animate",
+    "whileInView",
+    "whileFocus",
+    "whileHover",
+    "whileTap",
+    "whileDrag",
+    "exit",
+];
+const variantProps = ["initial", ...variantPriorityOrder];
+
+export { variantPriorityOrder, variantProps };