@epic-web/workshop-app 5.1.0 → 5.1.1

package/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs

@@ -1,80 +0,0 @@
-import { transformProps } from '../../render/html/utils/transform.mjs';
-import { animateMotionValue } from './motion-value.mjs';
-import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';
-import { setTarget } from '../../render/utils/setters.mjs';
-import { getValueTransition } from '../utils/transitions.mjs';
-import { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';
-import { frame } from '../../frameloop/frame.mjs';
-
-/**
- * Decide whether we should block this animation. Previously, we achieved this
- * just by checking whether the key was listed in protectedKeys, but this
- * posed problems if an animation was triggered by afterChildren and protectedKeys
- * had been set to true in the meantime.
- */
-function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
-    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
-    needsAnimating[key] = false;
-    return shouldBlock;
-}
-function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
-    var _a;
-    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;
-    const willChange = visualElement.getValue("willChange");
-    if (transitionOverride)
-        transition = transitionOverride;
-    const animations = [];
-    const animationTypeState = type &&
-        visualElement.animationState &&
-        visualElement.animationState.getState()[type];
-    for (const key in target) {
-        const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);
-        const valueTarget = target[key];
-        if (valueTarget === undefined ||
-            (animationTypeState &&
-                shouldBlockAnimation(animationTypeState, key))) {
-            continue;
-        }
-        const valueTransition = {
-            delay,
-            elapsed: 0,
-            ...getValueTransition(transition || {}, key),
-        };
-        /**
-         * If this is the first time a value is being animated, check
-         * to see if we're handling off from an existing animation.
-         */
-        let isHandoff = false;
-        if (window.HandoffAppearAnimations) {
-            const appearId = getOptimisedAppearId(visualElement);
-            if (appearId) {
-                const elapsed = window.HandoffAppearAnimations(appearId, key, value, frame);
-                if (elapsed !== null) {
-                    valueTransition.elapsed = elapsed;
-                    isHandoff = true;
-                }
-            }
-        }
-        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)
-            ? { type: false }
-            : valueTransition, visualElement, isHandoff));
-        const animation = value.animation;
-        if (animation) {
-            if (isWillChangeMotionValue(willChange)) {
-                willChange.add(key);
-                animation.then(() => willChange.remove(key));
-            }
-            animations.push(animation);
-        }
-    }
-    if (transitionEnd) {
-        Promise.all(animations).then(() => {
-            frame.update(() => {
-                transitionEnd && setTarget(visualElement, transitionEnd);
-            });
-        });
-    }
-    return animations;
-}
-
-export { animateTarget };

package/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs

@@ -1,66 +0,0 @@
-import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';
-import { animateTarget } from './visual-element-target.mjs';
-
-function animateVariant(visualElement, variant, options = {}) {
-    var _a;
-    const resolved = resolveVariant(visualElement, variant, options.type === "exit"
-        ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom
-        : undefined);
-    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
-    if (options.transitionOverride) {
-        transition = options.transitionOverride;
-    }
-    /**
-     * If we have a variant, create a callback that runs it as an animation.
-     * Otherwise, we resolve a Promise immediately for a composable no-op.
-     */
-    const getAnimation = resolved
-        ? () => Promise.all(animateTarget(visualElement, resolved, options))
-        : () => Promise.resolve();
-    /**
-     * If we have children, create a callback that runs all their animations.
-     * Otherwise, we resolve a Promise immediately for a composable no-op.
-     */
-    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size
-        ? (forwardDelay = 0) => {
-            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;
-            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);
-        }
-        : () => Promise.resolve();
-    /**
-     * If the transition explicitly defines a "when" option, we need to resolve either
-     * this animation or all children animations before playing the other.
-     */
-    const { when } = transition;
-    if (when) {
-        const [first, last] = when === "beforeChildren"
-            ? [getAnimation, getChildAnimations]
-            : [getChildAnimations, getAnimation];
-        return first().then(() => last());
-    }
-    else {
-        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);
-    }
-}
-function animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
-    const animations = [];
-    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;
-    const generateStaggerDuration = staggerDirection === 1
-        ? (i = 0) => i * staggerChildren
-        : (i = 0) => maxStaggerDuration - i * staggerChildren;
-    Array.from(visualElement.variantChildren)
-        .sort(sortByTreeOrder)
-        .forEach((child, i) => {
-        child.notify("AnimationStart", variant);
-        animations.push(animateVariant(child, variant, {
-            ...options,
-            delay: delayChildren + generateStaggerDuration(i),
-        }).then(() => child.notify("AnimationComplete", variant)));
-    });
-    return Promise.all(animations);
-}
-function sortByTreeOrder(a, b) {
-    return a.sortNodePosition(b);
-}
-
-export { animateVariant, sortByTreeOrder };

package/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs

@@ -1,29 +0,0 @@
-import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';
-import { animateTarget } from './visual-element-target.mjs';
-import { animateVariant } from './visual-element-variant.mjs';
-import { frame } from '../../frameloop/frame.mjs';
-
-function animateVisualElement(visualElement, definition, options = {}) {
-    visualElement.notify("AnimationStart", definition);
-    let animation;
-    if (Array.isArray(definition)) {
-        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));
-        animation = Promise.all(animations);
-    }
-    else if (typeof definition === "string") {
-        animation = animateVariant(visualElement, definition, options);
-    }
-    else {
-        const resolvedDefinition = typeof definition === "function"
-            ? resolveVariant(visualElement, definition, options.custom)
-            : definition;
-        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));
-    }
-    return animation.then(() => {
-        frame.postRender(() => {
-            visualElement.notify("AnimationComplete", definition);
-        });
-    });
-}
-
-export { animateVisualElement };

package/node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs

@@ -1,6 +0,0 @@
-import { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';
-
-const optimizedAppearDataId = "framerAppearId";
-const optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);
-
-export { optimizedAppearDataAttribute, optimizedAppearDataId };

package/node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs

@@ -1,7 +0,0 @@
-import { optimizedAppearDataAttribute } from './data-id.mjs';
-
-function getOptimisedAppearId(visualElement) {
-    return visualElement.getProps()[optimizedAppearDataAttribute];
-}
-
-export { getOptimisedAppearId };

package/node_modules/framer-motion/dist/es/animation/optimized-appear/handoff.mjs

@@ -1,83 +0,0 @@
-import { transformProps } from '../../render/html/utils/transform.mjs';
-import { appearAnimationStore } from './store.mjs';
-import { appearStoreId } from './store-id.mjs';
-
-let handoffFrameTime;
-function handoffOptimizedAppearAnimation(elementId, valueName, 
-/**
- * Legacy arguments. This function is inlined as part of SSG so it can be there's
- * a version mismatch between the main included Motion and the inlined script.
- *
- * Remove in early 2024.
- */
-_value, frame) {
-    const optimisedValueName = transformProps.has(valueName)
-        ? "transform"
-        : valueName;
-    const storeId = appearStoreId(elementId, optimisedValueName);
-    const optimisedAnimation = appearAnimationStore.get(storeId);
-    if (!optimisedAnimation) {
-        return null;
-    }
-    const { animation, startTime } = optimisedAnimation;
-    const cancelAnimation = () => {
-        appearAnimationStore.delete(storeId);
-        if (frame) {
-            /**
-             * If we've been provided the frameloop as an argument, use it to defer
-             * cancellation until keyframes of the subsequent animation have been resolved.
-             * This "papers over" a gap where the JS animations haven't rendered with
-             * the latest time after a potential heavy blocking workload.
-             * Otherwise cancel immediately.
-             *
-             * This is an optional dependency to deal with the fact that this inline
-             * script and the library can be version sharded, and there have been
-             * times when this isn't provided as an argument.
-             */
-            frame.render(() => frame.render(() => {
-                try {
-                    animation.cancel();
-                }
-                catch (error) { }
-            }));
-        }
-        else {
-            try {
-                animation.cancel();
-            }
-            catch (error) { }
-        }
-    };
-    /**
-     * If the startTime is null, this animation is the Paint Ready detection animation
-     * and we can cancel it immediately without handoff.
-     *
-     * Or if we've already handed off the animation then we're now interrupting it.
-     * In which case we need to cancel it.
-     */
-    if (startTime === null || window.HandoffComplete) {
-        cancelAnimation();
-        return null;
-    }
-    else {
-        /**
-         * Otherwise we're handing off this animation to the main thread.
-         *
-         * Record the time of the first handoff. We call performance.now() once
-         * here and once in startOptimisedAnimation to ensure we're getting
-         * close to a frame-locked time. This keeps all animations in sync.
-         */
-        if (handoffFrameTime === undefined) {
-            handoffFrameTime = performance.now();
-        }
-        /**
-         * We use main thread timings vs those returned by Animation.currentTime as it
-         * can be the case, particularly in Firefox, that currentTime doesn't return
-         * an updated value for several frames, even as the animation plays smoothly via
-         * the GPU.
-         */
-        return handoffFrameTime - startTime || 0;
-    }
-}
-
-export { handoffOptimizedAppearAnimation };

package/node_modules/framer-motion/dist/es/animation/optimized-appear/start.mjs

@@ -1,80 +0,0 @@
-import { appearStoreId } from './store-id.mjs';
-import { animateStyle } from '../animators/waapi/index.mjs';
-import { optimizedAppearDataId } from './data-id.mjs';
-import { handoffOptimizedAppearAnimation } from './handoff.mjs';
-import { appearAnimationStore } from './store.mjs';
-import { noop } from '../../utils/noop.mjs';
-
-/**
- * A single time to use across all animations to manually set startTime
- * and ensure they're all in sync.
- */
-let startFrameTime;
-/**
- * A dummy animation to detect when Chrome is ready to start
- * painting the page and hold off from triggering the real animation
- * until then. We only need one animation to detect paint ready.
- *
- * https://bugs.chromium.org/p/chromium/issues/detail?id=1406850
- */
-let readyAnimation;
-function startOptimizedAppearAnimation(element, name, keyframes, options, onReady) {
-    // Prevent optimised appear animations if Motion has already started animating.
-    if (window.HandoffComplete) {
-        window.HandoffAppearAnimations = undefined;
-        return;
-    }
-    const id = element.dataset[optimizedAppearDataId];
-    if (!id)
-        return;
-    window.HandoffAppearAnimations = handoffOptimizedAppearAnimation;
-    const storeId = appearStoreId(id, name);
-    if (!readyAnimation) {
-        readyAnimation = animateStyle(element, name, [keyframes[0], keyframes[0]], 
-        /**
-         * 10 secs is basically just a super-safe duration to give Chrome
-         * long enough to get the animation ready.
-         */
-        { duration: 10000, ease: "linear" });
-        appearAnimationStore.set(storeId, {
-            animation: readyAnimation,
-            startTime: null,
-        });
-        if (!window.HandoffCancelAllAnimations) {
-            window.HandoffCancelAllAnimations = () => {
-                appearAnimationStore.forEach(({ animation }) => {
-                    animation.cancel();
-                });
-                appearAnimationStore.clear();
-                window.HandoffCancelAllAnimations = undefined;
-            };
-        }
-    }
-    const startAnimation = () => {
-        readyAnimation.cancel();
-        const appearAnimation = animateStyle(element, name, keyframes, options);
-        /**
-         * Record the time of the first started animation. We call performance.now() once
-         * here and once in handoff to ensure we're getting
-         * close to a frame-locked time. This keeps all animations in sync.
-         */
-        if (startFrameTime === undefined) {
-            startFrameTime = performance.now();
-        }
-        appearAnimation.startTime = startFrameTime;
-        appearAnimationStore.set(storeId, {
-            animation: appearAnimation,
-            startTime: startFrameTime,
-        });
-        if (onReady)
-            onReady(appearAnimation);
-    };
-    if (readyAnimation.ready) {
-        readyAnimation.ready.then(startAnimation).catch(noop);
-    }
-    else {
-        startAnimation();
-    }
-}
-
-export { startOptimizedAppearAnimation };

package/node_modules/framer-motion/dist/es/animation/optimized-appear/store-id.mjs

@@ -1,3 +0,0 @@
-const appearStoreId = (id, value) => `${id}: ${value}`;
-
-export { appearStoreId };

package/node_modules/framer-motion/dist/es/animation/optimized-appear/store.mjs

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

package/node_modules/framer-motion/dist/es/animation/sequence/create.mjs

@@ -1,230 +0,0 @@
-import { createGeneratorEasing } from '../../easing/utils/create-generator-easing.mjs';
-import { resolveElements } from '../../render/dom/utils/resolve-element.mjs';
-import { defaultOffset } from '../../utils/offsets/default.mjs';
-import { fillOffset } from '../../utils/offsets/fill.mjs';
-import { progress } from '../../utils/progress.mjs';
-import { secondsToMilliseconds } from '../../utils/time-conversion.mjs';
-import { isMotionValue } from '../../value/utils/is-motion-value.mjs';
-import { calcNextTime } from './utils/calc-time.mjs';
-import { addKeyframes } from './utils/edit.mjs';
-import { compareByTime } from './utils/sort.mjs';
-
-const defaultSegmentEasing = "easeInOut";
-function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...sequenceTransition } = {}, scope) {
-    const defaultDuration = defaultTransition.duration || 0.3;
-    const animationDefinitions = new Map();
-    const sequences = new Map();
-    const elementCache = {};
-    const timeLabels = new Map();
-    let prevTime = 0;
-    let currentTime = 0;
-    let totalDuration = 0;
-    /**
-     * Build the timeline by mapping over the sequence array and converting
-     * the definitions into keyframes and offsets with absolute time values.
-     * These will later get converted into relative offsets in a second pass.
-     */
-    for (let i = 0; i < sequence.length; i++) {
-        const segment = sequence[i];
-        /**
-         * If this is a timeline label, mark it and skip the rest of this iteration.
-         */
-        if (typeof segment === "string") {
-            timeLabels.set(segment, currentTime);
-            continue;
-        }
-        else if (!Array.isArray(segment)) {
-            timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));
-            continue;
-        }
-        let [subject, keyframes, transition = {}] = segment;
-        /**
-         * If a relative or absolute time value has been specified we need to resolve
-         * it in relation to the currentTime.
-         */
-        if (transition.at !== undefined) {
-            currentTime = calcNextTime(currentTime, transition.at, prevTime, timeLabels);
-        }
-        /**
-         * Keep track of the maximum duration in this definition. This will be
-         * applied to currentTime once the definition has been parsed.
-         */
-        let maxDuration = 0;
-        const resolveValueSequence = (valueKeyframes, valueTransition, valueSequence, elementIndex = 0, numElements = 0) => {
-            const valueKeyframesAsList = keyframesAsList(valueKeyframes);
-            const { delay = 0, times = defaultOffset(valueKeyframesAsList), type = "keyframes", ...remainingTransition } = valueTransition;
-            let { ease = defaultTransition.ease || "easeOut", duration } = valueTransition;
-            /**
-             * Resolve stagger() if defined.
-             */
-            const calculatedDelay = typeof delay === "function"
-                ? delay(elementIndex, numElements)
-                : delay;
-            /**
-             * If this animation should and can use a spring, generate a spring easing function.
-             */
-            const numKeyframes = valueKeyframesAsList.length;
-            if (numKeyframes <= 2 && type === "spring") {
-                /**
-                 * As we're creating an easing function from a spring,
-                 * ideally we want to generate it using the real distance
-                 * between the two keyframes. However this isn't always
-                 * possible - in these situations we use 0-100.
-                 */
-                let absoluteDelta = 100;
-                if (numKeyframes === 2 &&
-                    isNumberKeyframesArray(valueKeyframesAsList)) {
-                    const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];
-                    absoluteDelta = Math.abs(delta);
-                }
-                const springTransition = { ...remainingTransition };
-                if (duration !== undefined) {
-                    springTransition.duration = secondsToMilliseconds(duration);
-                }
-                const springEasing = createGeneratorEasing(springTransition, absoluteDelta);
-                ease = springEasing.ease;
-                duration = springEasing.duration;
-            }
-            duration !== null && duration !== void 0 ? duration : (duration = defaultDuration);
-            const startTime = currentTime + calculatedDelay;
-            const targetTime = startTime + duration;
-            /**
-             * If there's only one time offset of 0, fill in a second with length 1
-             */
-            if (times.length === 1 && times[0] === 0) {
-                times[1] = 1;
-            }
-            /**
-             * Fill out if offset if fewer offsets than keyframes
-             */
-            const remainder = times.length - valueKeyframesAsList.length;
-            remainder > 0 && fillOffset(times, remainder);
-            /**
-             * If only one value has been set, ie [1], push a null to the start of
-             * the keyframe array. This will let us mark a keyframe at this point
-             * that will later be hydrated with the previous value.
-             */
-            valueKeyframesAsList.length === 1 &&
-                valueKeyframesAsList.unshift(null);
-            /**
-             * Add keyframes, mapping offsets to absolute time.
-             */
-            addKeyframes(valueSequence, valueKeyframesAsList, ease, times, startTime, targetTime);
-            maxDuration = Math.max(calculatedDelay + duration, maxDuration);
-            totalDuration = Math.max(targetTime, totalDuration);
-        };
-        if (isMotionValue(subject)) {
-            const subjectSequence = getSubjectSequence(subject, sequences);
-            resolveValueSequence(keyframes, transition, getValueSequence("default", subjectSequence));
-        }
-        else {
-            /**
-             * Find all the elements specified in the definition and parse value
-             * keyframes from their timeline definitions.
-             */
-            const elements = resolveElements(subject, scope, elementCache);
-            const numElements = elements.length;
-            /**
-             * For every element in this segment, process the defined values.
-             */
-            for (let elementIndex = 0; elementIndex < numElements; elementIndex++) {
-                /**
-                 * Cast necessary, but we know these are of this type
-                 */
-                keyframes = keyframes;
-                transition = transition;
-                const element = elements[elementIndex];
-                const subjectSequence = getSubjectSequence(element, sequences);
-                for (const key in keyframes) {
-                    resolveValueSequence(keyframes[key], getValueTransition(transition, key), getValueSequence(key, subjectSequence), elementIndex, numElements);
-                }
-            }
-        }
-        prevTime = currentTime;
-        currentTime += maxDuration;
-    }
-    /**
-     * For every element and value combination create a new animation.
-     */
-    sequences.forEach((valueSequences, element) => {
-        for (const key in valueSequences) {
-            const valueSequence = valueSequences[key];
-            /**
-             * Arrange all the keyframes in ascending time order.
-             */
-            valueSequence.sort(compareByTime);
-            const keyframes = [];
-            const valueOffset = [];
-            const valueEasing = [];
-            /**
-             * For each keyframe, translate absolute times into
-             * relative offsets based on the total duration of the timeline.
-             */
-            for (let i = 0; i < valueSequence.length; i++) {
-                const { at, value, easing } = valueSequence[i];
-                keyframes.push(value);
-                valueOffset.push(progress(0, totalDuration, at));
-                valueEasing.push(easing || "easeOut");
-            }
-            /**
-             * If the first keyframe doesn't land on offset: 0
-             * provide one by duplicating the initial keyframe. This ensures
-             * it snaps to the first keyframe when the animation starts.
-             */
-            if (valueOffset[0] !== 0) {
-                valueOffset.unshift(0);
-                keyframes.unshift(keyframes[0]);
-                valueEasing.unshift(defaultSegmentEasing);
-            }
-            /**
-             * If the last keyframe doesn't land on offset: 1
-             * provide one with a null wildcard value. This will ensure it
-             * stays static until the end of the animation.
-             */
-            if (valueOffset[valueOffset.length - 1] !== 1) {
-                valueOffset.push(1);
-                keyframes.push(null);
-            }
-            if (!animationDefinitions.has(element)) {
-                animationDefinitions.set(element, {
-                    keyframes: {},
-                    transition: {},
-                });
-            }
-            const definition = animationDefinitions.get(element);
-            definition.keyframes[key] = keyframes;
-            definition.transition[key] = {
-                ...defaultTransition,
-                duration: totalDuration,
-                ease: valueEasing,
-                times: valueOffset,
-                ...sequenceTransition,
-            };
-        }
-    });
-    return animationDefinitions;
-}
-function getSubjectSequence(subject, sequences) {
-    !sequences.has(subject) && sequences.set(subject, {});
-    return sequences.get(subject);
-}
-function getValueSequence(name, sequences) {
-    if (!sequences[name])
-        sequences[name] = [];
-    return sequences[name];
-}
-function keyframesAsList(keyframes) {
-    return Array.isArray(keyframes) ? keyframes : [keyframes];
-}
-function getValueTransition(transition, key) {
-    return transition[key]
-        ? {
-            ...transition,
-            ...transition[key],
-        }
-        : { ...transition };
-}
-const isNumber = (keyframe) => typeof keyframe === "number";
-const isNumberKeyframesArray = (keyframes) => keyframes.every(isNumber);
-
-export { createAnimationsFromSequence, getValueTransition };

package/node_modules/framer-motion/dist/es/animation/sequence/utils/calc-time.mjs

@@ -1,21 +0,0 @@
-/**
- * Given a absolute or relative time definition and current/prev time state of the sequence,
- * calculate an absolute time for the next keyframes.
- */
-function calcNextTime(current, next, prev, labels) {
-    var _a;
-    if (typeof next === "number") {
-        return next;
-    }
-    else if (next.startsWith("-") || next.startsWith("+")) {
-        return Math.max(0, current + parseFloat(next));
-    }
-    else if (next === "<") {
-        return prev;
-    }
-    else {
-        return (_a = labels.get(next)) !== null && _a !== void 0 ? _a : current;
-    }
-}
-
-export { calcNextTime };

package/node_modules/framer-motion/dist/es/animation/sequence/utils/edit.mjs

@@ -1,31 +0,0 @@
-import { getEasingForSegment } from '../../../easing/utils/get-easing-for-segment.mjs';
-import { removeItem } from '../../../utils/array.mjs';
-import { mixNumber } from '../../../utils/mix/number.mjs';
-
-function eraseKeyframes(sequence, startTime, endTime) {
-    for (let i = 0; i < sequence.length; i++) {
-        const keyframe = sequence[i];
-        if (keyframe.at > startTime && keyframe.at < endTime) {
-            removeItem(sequence, keyframe);
-            // If we remove this item we have to push the pointer back one
-            i--;
-        }
-    }
-}
-function addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {
-    /**
-     * Erase every existing value between currentTime and targetTime,
-     * this will essentially splice this timeline into any currently
-     * defined ones.
-     */
-    eraseKeyframes(sequence, startTime, endTime);
-    for (let i = 0; i < keyframes.length; i++) {
-        sequence.push({
-            value: keyframes[i],
-            at: mixNumber(startTime, endTime, offset[i]),
-            easing: getEasingForSegment(easing, i),
-        });
-    }
-}
-
-export { addKeyframes, eraseKeyframes };

package/node_modules/framer-motion/dist/es/animation/sequence/utils/sort.mjs

@@ -1,14 +0,0 @@
-function compareByTime(a, b) {
-    if (a.at === b.at) {
-        if (a.value === null)
-            return 1;
-        if (b.value === null)
-            return -1;
-        return 0;
-    }
-    else {
-        return a.at - b.at;
-    }
-}
-
-export { compareByTime };