@ape.swap/bonds-sdk 5.1.0 → 5.1.1-test.0

package/dist/node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.js

@@ -0,0 +1,165 @@
+import { removeNonTranslationalTransform } from '../dom/utils/unit-conversion.js';
+import { frame } from '../../frameloop/frame.js';
+
+const toResolve = new Set();
+let isScheduled = false;
+let anyNeedsMeasurement = false;
+function measureAllKeyframes() {
+    if (anyNeedsMeasurement) {
+        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);
+        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));
+        const transformsToRestore = new Map();
+        /**
+         * Write pass
+         * If we're measuring elements we want to remove bounding box-changing transforms.
+         */
+        elementsToMeasure.forEach((element) => {
+            const removedTransforms = removeNonTranslationalTransform(element);
+            if (!removedTransforms.length)
+                return;
+            transformsToRestore.set(element, removedTransforms);
+            element.render();
+        });
+        // Read
+        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
+        // Write
+        elementsToMeasure.forEach((element) => {
+            element.render();
+            const restore = transformsToRestore.get(element);
+            if (restore) {
+                restore.forEach(([key, value]) => {
+                    var _a;
+                    (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);
+                });
+            }
+        });
+        // Read
+        resolversToMeasure.forEach((resolver) => resolver.measureEndState());
+        // Write
+        resolversToMeasure.forEach((resolver) => {
+            if (resolver.suspendedScrollY !== undefined) {
+                window.scrollTo(0, resolver.suspendedScrollY);
+            }
+        });
+    }
+    anyNeedsMeasurement = false;
+    isScheduled = false;
+    toResolve.forEach((resolver) => resolver.complete());
+    toResolve.clear();
+}
+function readAllKeyframes() {
+    toResolve.forEach((resolver) => {
+        resolver.readKeyframes();
+        if (resolver.needsMeasurement) {
+            anyNeedsMeasurement = true;
+        }
+    });
+}
+function flushKeyframeResolvers() {
+    readAllKeyframes();
+    measureAllKeyframes();
+}
+class KeyframeResolver {
+    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {
+        /**
+         * Track whether this resolver has completed. Once complete, it never
+         * needs to attempt keyframe resolution again.
+         */
+        this.isComplete = false;
+        /**
+         * Track whether this resolver is async. If it is, it'll be added to the
+         * resolver queue and flushed in the next frame. Resolvers that aren't going
+         * to trigger read/write thrashing don't need to be async.
+         */
+        this.isAsync = false;
+        /**
+         * Track whether this resolver needs to perform a measurement
+         * to resolve its keyframes.
+         */
+        this.needsMeasurement = false;
+        /**
+         * Track whether this resolver is currently scheduled to resolve
+         * to allow it to be cancelled and resumed externally.
+         */
+        this.isScheduled = false;
+        this.unresolvedKeyframes = [...unresolvedKeyframes];
+        this.onComplete = onComplete;
+        this.name = name;
+        this.motionValue = motionValue;
+        this.element = element;
+        this.isAsync = isAsync;
+    }
+    scheduleResolve() {
+        this.isScheduled = true;
+        if (this.isAsync) {
+            toResolve.add(this);
+            if (!isScheduled) {
+                isScheduled = true;
+                frame.read(readAllKeyframes);
+                frame.resolveKeyframes(measureAllKeyframes);
+            }
+        }
+        else {
+            this.readKeyframes();
+            this.complete();
+        }
+    }
+    readKeyframes() {
+        const { unresolvedKeyframes, name, element, motionValue } = this;
+        /**
+         * If a keyframe is null, we hydrate it either by reading it from
+         * the instance, or propagating from previous keyframes.
+         */
+        for (let i = 0; i < unresolvedKeyframes.length; i++) {
+            if (unresolvedKeyframes[i] === null) {
+                /**
+                 * If the first keyframe is null, we need to find its value by sampling the element
+                 */
+                if (i === 0) {
+                    const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();
+                    const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
+                    if (currentValue !== undefined) {
+                        unresolvedKeyframes[0] = currentValue;
+                    }
+                    else if (element && name) {
+                        const valueAsRead = element.readValue(name, finalKeyframe);
+                        if (valueAsRead !== undefined && valueAsRead !== null) {
+                            unresolvedKeyframes[0] = valueAsRead;
+                        }
+                    }
+                    if (unresolvedKeyframes[0] === undefined) {
+                        unresolvedKeyframes[0] = finalKeyframe;
+                    }
+                    if (motionValue && currentValue === undefined) {
+                        motionValue.set(unresolvedKeyframes[0]);
+                    }
+                }
+                else {
+                    unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];
+                }
+            }
+        }
+    }
+    setFinalKeyframe() { }
+    measureInitialState() { }
+    renderEndStyles() { }
+    measureEndState() { }
+    complete() {
+        this.isComplete = true;
+        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);
+        toResolve.delete(this);
+    }
+    cancel() {
+        if (!this.isComplete) {
+            this.isScheduled = false;
+            toResolve.delete(this);
+        }
+    }
+    resume() {
+        if (!this.isComplete)
+            this.scheduleResolve();
+    }
+}
+
+export { KeyframeResolver, flushKeyframeResolvers };
+//# sourceMappingURL=KeyframesResolver.js.map

package/dist/node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyframesResolver.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs"],"sourcesContent":["import { removeNonTranslationalTransform } from '../dom/utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    var _a;\n                    (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete());\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    readAllKeyframes();\n    measureAllKeyframes();\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        /**\n         * Track whether this resolver has completed. Once complete, it never\n         * needs to attempt keyframe resolution again.\n         */\n        this.isComplete = false;\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        /**\n         * Track whether this resolver is currently scheduled to resolve\n         * to allow it to be cancelled and resumed externally.\n         */\n        this.isScheduled = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.isScheduled = true;\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        /**\n         * If a keyframe is null, we hydrate it either by reading it from\n         * the instance, or propagating from previous keyframes.\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null) {\n                /**\n                 * If the first keyframe is null, we need to find its value by sampling the element\n                 */\n                if (i === 0) {\n                    const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();\n                    const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n                    if (currentValue !== undefined) {\n                        unresolvedKeyframes[0] = currentValue;\n                    }\n                    else if (element && name) {\n                        const valueAsRead = element.readValue(name, finalKeyframe);\n                        if (valueAsRead !== undefined && valueAsRead !== null) {\n                            unresolvedKeyframes[0] = valueAsRead;\n                        }\n                    }\n                    if (unresolvedKeyframes[0] === undefined) {\n                        unresolvedKeyframes[0] = finalKeyframe;\n                    }\n                    if (motionValue && currentValue === undefined) {\n                        motionValue.set(unresolvedKeyframes[0]);\n                    }\n                }\n                else {\n                    unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];\n                }\n            }\n        }\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete() {\n        this.isComplete = true;\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (!this.isComplete) {\n            this.isScheduled = false;\n            toResolve.delete(this);\n        }\n    }\n    resume() {\n        if (!this.isComplete)\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,333 @@
+import { isAnimationControls } from '../../animation/utils/is-animation-controls.js';
+import { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.js';
+import { shallowCompare } from '../../utils/shallow-compare.js';
+import { isVariantLabel } from './is-variant-label.js';
+import { resolveVariant } from './resolve-dynamic-variants.js';
+import { variantPriorityOrder } from './variant-props.js';
+import { animateVisualElement } from '../../animation/interfaces/visual-element.js';
+import { getVariantContext } from './get-variant-context.js';
+
+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) => {
+        var _a;
+        const resolved = resolveVariant(visualElement, definition, type === "exit"
+            ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.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) => ({
+                    animation: animation,
+                    options: { type },
+                })));
+            }
+        }
+        /**
+         * 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 = {};
+            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 && fallbackTarget !== void 0 ? 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) {
+        var _a;
+        // 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
+        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.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();
+            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 };
+//# sourceMappingURL=animation-state.js.map

package/dist/node_modules/framer-motion/dist/es/render/utils/animation-state.js.map

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

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

@@ -0,0 +1,4 @@
+const compareByDepth = (a, b) => a.depth - b.depth;
+
+export { compareByDepth };
+//# sourceMappingURL=compare-by-depth.js.map

package/dist/node_modules/framer-motion/dist/es/render/utils/compare-by-depth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-by-depth.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs"],"sourcesContent":["const compareByDepth = (a, b) => a.depth - b.depth;\n\nexport { compareByDepth };\n"],"names":[],"mappings":"AAAK,MAAC,cAAc,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,25 @@
+import { addUniqueItem, removeItem } from '../../utils/array.js';
+import { compareByDepth } from './compare-by-depth.js';
+
+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 };
+//# sourceMappingURL=flat-tree.js.map

package/dist/node_modules/framer-motion/dist/es/render/utils/flat-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-tree.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs"],"sourcesContent":["import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\nexport { FlatTree };\n"],"names":[],"mappings":";;;AAGA,MAAM,QAAQ,CAAC;AACf,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,QAAQ,GAAG,EAAE;AAC1B,QAAQ,IAAI,CAAC,OAAO,GAAG,KAAK;AAC5B,IAAI;AACJ,IAAI,GAAG,CAAC,KAAK,EAAE;AACf,QAAQ,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC;AAC3C,QAAQ,IAAI,CAAC,OAAO,GAAG,IAAI;AAC3B,IAAI;AACJ,IAAI,MAAM,CAAC,KAAK,EAAE;AAClB,QAAQ,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC;AACxC,QAAQ,IAAI,CAAC,OAAO,GAAG,IAAI;AAC3B,IAAI;AACJ,IAAI,OAAO,CAAC,QAAQ,EAAE;AACtB,QAAQ,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC;AAC1D,QAAQ,IAAI,CAAC,OAAO,GAAG,KAAK;AAC5B,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC;AACvC,IAAI;AACJ;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,29 @@
+import { isVariantLabel } from './is-variant-label.js';
+import { variantProps } from './variant-props.js';
+
+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 };
+//# sourceMappingURL=get-variant-context.js.map

package/dist/node_modules/framer-motion/dist/es/render/utils/get-variant-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-variant-context.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/render/utils/get-variant-context.mjs"],"sourcesContent":["import { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nconst numVariantProps = variantProps.length;\nfunction getVariantContext(visualElement) {\n    if (!visualElement)\n        return undefined;\n    if (!visualElement.isControllingVariants) {\n        const context = visualElement.parent\n            ? getVariantContext(visualElement.parent) || {}\n            : {};\n        if (visualElement.props.initial !== undefined) {\n            context.initial = visualElement.props.initial;\n        }\n        return context;\n    }\n    const context = {};\n    for (let i = 0; i < numVariantProps; i++) {\n        const name = variantProps[i];\n        const prop = visualElement.props[name];\n        if (isVariantLabel(prop) || prop === false) {\n            context[name] = prop;\n        }\n    }\n    return context;\n}\n\nexport { getVariantContext };\n"],"names":[],"mappings":";;;AAGA,MAAM,eAAe,GAAG,YAAY,CAAC,MAAM;AAC3C,SAAS,iBAAiB,CAAC,aAAa,EAAE;AAC1C,IAAI,IAAI,CAAC,aAAa;AACtB,QAAQ,OAAO,SAAS;AACxB,IAAI,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE;AAC9C,QAAQ,MAAM,OAAO,GAAG,aAAa,CAAC;AACtC,cAAc,iBAAiB,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI;AACzD,cAAc,EAAE;AAChB,QAAQ,IAAI,aAAa,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE;AACvD,YAAY,OAAO,CAAC,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,OAAO;AACzD,QAAQ;AACR,QAAQ,OAAO,OAAO;AACtB,IAAI;AACJ,IAAI,MAAM,OAAO,GAAG,EAAE;AACtB,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,EAAE;AAC9C,QAAQ,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC;AACpC,QAAQ,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC;AAC9C,QAAQ,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,KAAK,EAAE;AACpD,YAAY,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;AAChC,QAAQ;AACR,IAAI;AACJ,IAAI,OAAO,OAAO;AAClB;;;;","x_google_ignoreList":[0]}