@teamturing/react-kit 2.51.3 → 2.51.5

package/esm/node_modules/framer-motion/dist/es/animation/generators/keyframes.js

@@ -1,51 +0,0 @@
-import { easeInOut } from '../../easing/ease.js';
-import { isEasingArray } from '../../easing/utils/is-easing-array.js';
-import { easingDefinitionToFunction } from '../../easing/utils/map.js';
-import { interpolate } from '../../utils/interpolate.js';
-import { defaultOffset } from '../../utils/offsets/default.js';
-import { convertOffsetToTimes } from '../../utils/offsets/time.js';
-
-function defaultEasing(values, easing) {
-    return values.map(() => easing || easeInOut).splice(0, values.length - 1);
-}
-function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut", }) {
-    /**
-     * Easing functions can be externally defined as strings. Here we convert them
-     * into actual functions.
-     */
-    const easingFunctions = isEasingArray(ease)
-        ? ease.map(easingDefinitionToFunction)
-        : easingDefinitionToFunction(ease);
-    /**
-     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
-     * to reduce GC during animation.
-     */
-    const state = {
-        done: false,
-        value: keyframeValues[0],
-    };
-    /**
-     * Create a times array based on the provided 0-1 offsets
-     */
-    const absoluteTimes = convertOffsetToTimes(
-    // Only use the provided offsets if they're the correct length
-    // TODO Maybe we should warn here if there's a length mismatch
-    times && times.length === keyframeValues.length
-        ? times
-        : defaultOffset(keyframeValues), duration);
-    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {
-        ease: Array.isArray(easingFunctions)
-            ? easingFunctions
-            : defaultEasing(keyframeValues, easingFunctions),
-    });
-    return {
-        calculatedDuration: duration,
-        next: (t) => {
-            state.value = mapTimeToKeyframe(t);
-            state.done = t >= duration;
-            return state;
-        },
-    };
-}
-
-export { defaultEasing, keyframes };

package/esm/node_modules/framer-motion/dist/es/animation/generators/spring/find.js

@@ -1,89 +0,0 @@
-import { warning } from '../../../utils/errors.js';
-import { clamp } from '../../../utils/clamp.js';
-import { secondsToMilliseconds, millisecondsToSeconds } from '../../../utils/time-conversion.js';
-
-const safeMin = 0.001;
-const minDuration = 0.01;
-const maxDuration = 10.0;
-const minDamping = 0.05;
-const maxDamping = 1;
-function findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {
-    let envelope;
-    let derivative;
-    warning(duration <= secondsToMilliseconds(maxDuration), "Spring duration must be 10 seconds or less");
-    let dampingRatio = 1 - bounce;
-    /**
-     * Restrict dampingRatio and duration to within acceptable ranges.
-     */
-    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);
-    duration = clamp(minDuration, maxDuration, millisecondsToSeconds(duration));
-    if (dampingRatio < 1) {
-        /**
-         * Underdamped spring
-         */
-        envelope = (undampedFreq) => {
-            const exponentialDecay = undampedFreq * dampingRatio;
-            const delta = exponentialDecay * duration;
-            const a = exponentialDecay - velocity;
-            const b = calcAngularFreq(undampedFreq, dampingRatio);
-            const c = Math.exp(-delta);
-            return safeMin - (a / b) * c;
-        };
-        derivative = (undampedFreq) => {
-            const exponentialDecay = undampedFreq * dampingRatio;
-            const delta = exponentialDecay * duration;
-            const d = delta * velocity + velocity;
-            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;
-            const f = Math.exp(-delta);
-            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);
-            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;
-            return (factor * ((d - e) * f)) / g;
-        };
-    }
-    else {
-        /**
-         * Critically-damped spring
-         */
-        envelope = (undampedFreq) => {
-            const a = Math.exp(-undampedFreq * duration);
-            const b = (undampedFreq - velocity) * duration + 1;
-            return -safeMin + a * b;
-        };
-        derivative = (undampedFreq) => {
-            const a = Math.exp(-undampedFreq * duration);
-            const b = (velocity - undampedFreq) * (duration * duration);
-            return a * b;
-        };
-    }
-    const initialGuess = 5 / duration;
-    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
-    duration = secondsToMilliseconds(duration);
-    if (isNaN(undampedFreq)) {
-        return {
-            stiffness: 100,
-            damping: 10,
-            duration,
-        };
-    }
-    else {
-        const stiffness = Math.pow(undampedFreq, 2) * mass;
-        return {
-            stiffness,
-            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
-            duration,
-        };
-    }
-}
-const rootIterations = 12;
-function approximateRoot(envelope, derivative, initialGuess) {
-    let result = initialGuess;
-    for (let i = 1; i < rootIterations; i++) {
-        result = result - envelope(result) / derivative(result);
-    }
-    return result;
-}
-function calcAngularFreq(undampedFreq, dampingRatio) {
-    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
-}
-
-export { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };

package/esm/node_modules/framer-motion/dist/es/animation/generators/spring/index.js

@@ -1,129 +0,0 @@
-import { millisecondsToSeconds } from '../../../utils/time-conversion.js';
-import { calcGeneratorVelocity } from '../utils/velocity.js';
-import { findSpring, calcAngularFreq } from './find.js';
-
-const durationKeys = ["duration", "bounce"];
-const physicsKeys = ["stiffness", "damping", "mass"];
-function isSpringType(options, keys) {
-    return keys.some((key) => options[key] !== undefined);
-}
-function getSpringOptions(options) {
-    let springOptions = {
-        velocity: 0.0,
-        stiffness: 100,
-        damping: 10,
-        mass: 1.0,
-        isResolvedFromDuration: false,
-        ...options,
-    };
-    // stiffness/damping/mass overrides duration/bounce
-    if (!isSpringType(options, physicsKeys) &&
-        isSpringType(options, durationKeys)) {
-        const derived = findSpring(options);
-        springOptions = {
-            ...springOptions,
-            ...derived,
-            velocity: 0.0,
-            mass: 1.0,
-        };
-        springOptions.isResolvedFromDuration = true;
-    }
-    return springOptions;
-}
-function spring({ keyframes, restDelta, restSpeed, ...options }) {
-    const origin = keyframes[0];
-    const target = keyframes[keyframes.length - 1];
-    /**
-     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
-     * to reduce GC during animation.
-     */
-    const state = { done: false, value: origin };
-    const { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);
-    const initialVelocity = velocity ? -millisecondsToSeconds(velocity) : 0.0;
-    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
-    const initialDelta = target - origin;
-    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
-    /**
-     * If we're working on a granular scale, use smaller defaults for determining
-     * when the spring is finished.
-     *
-     * These defaults have been selected emprically based on what strikes a good
-     * ratio between feeling good and finishing as soon as changes are imperceptible.
-     */
-    const isGranularScale = Math.abs(initialDelta) < 5;
-    restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);
-    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);
-    let resolveSpring;
-    if (dampingRatio < 1) {
-        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
-        // Underdamped spring
-        resolveSpring = (t) => {
-            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-            return (target -
-                envelope *
-                    (((initialVelocity +
-                        dampingRatio * undampedAngularFreq * initialDelta) /
-                        angularFreq) *
-                        Math.sin(angularFreq * t) +
-                        initialDelta * Math.cos(angularFreq * t)));
-        };
-    }
-    else if (dampingRatio === 1) {
-        // Critically damped spring
-        resolveSpring = (t) => target -
-            Math.exp(-undampedAngularFreq * t) *
-                (initialDelta +
-                    (initialVelocity + undampedAngularFreq * initialDelta) * t);
-    }
-    else {
-        // Overdamped spring
-        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
-        resolveSpring = (t) => {
-            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-            // When performing sinh or cosh values can hit Infinity so we cap them here
-            const freqForT = Math.min(dampedAngularFreq * t, 300);
-            return (target -
-                (envelope *
-                    ((initialVelocity +
-                        dampingRatio * undampedAngularFreq * initialDelta) *
-                        Math.sinh(freqForT) +
-                        dampedAngularFreq *
-                            initialDelta *
-                            Math.cosh(freqForT))) /
-                    dampedAngularFreq);
-        };
-    }
-    return {
-        calculatedDuration: isResolvedFromDuration ? duration || null : null,
-        next: (t) => {
-            const current = resolveSpring(t);
-            if (!isResolvedFromDuration) {
-                let currentVelocity = initialVelocity;
-                if (t !== 0) {
-                    /**
-                     * We only need to calculate velocity for under-damped springs
-                     * as over- and critically-damped springs can't overshoot, so
-                     * checking only for displacement is enough.
-                     */
-                    if (dampingRatio < 1) {
-                        currentVelocity = calcGeneratorVelocity(resolveSpring, t, current);
-                    }
-                    else {
-                        currentVelocity = 0;
-                    }
-                }
-                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
-                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
-                state.done =
-                    isBelowVelocityThreshold && isBelowDisplacementThreshold;
-            }
-            else {
-                state.done = t >= duration;
-            }
-            state.value = state.done ? target : current;
-            return state;
-        },
-    };
-}
-
-export { spring };

package/esm/node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.js

@@ -1,17 +0,0 @@
-/**
- * Implement a practical max duration for keyframe generation
- * to prevent infinite loops
- */
-const maxGeneratorDuration = 20000;
-function calcGeneratorDuration(generator) {
-    let duration = 0;
-    const timeStep = 50;
-    let state = generator.next(duration);
-    while (!state.done && duration < maxGeneratorDuration) {
-        duration += timeStep;
-        state = generator.next(duration);
-    }
-    return duration >= maxGeneratorDuration ? Infinity : duration;
-}
-
-export { calcGeneratorDuration, maxGeneratorDuration };

package/esm/node_modules/framer-motion/dist/es/animation/generators/utils/velocity.js

@@ -1,9 +0,0 @@
-import { velocityPerSecond } from '../../../utils/velocity-per-second.js';
-
-const velocitySampleDuration = 5; // ms
-function calcGeneratorVelocity(resolveValue, t, current) {
-    const prevT = Math.max(t - velocitySampleDuration, 0);
-    return velocityPerSecond(current - resolveValue(prevT), t - prevT);
-}
-
-export { calcGeneratorVelocity };

package/esm/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.js

@@ -1,101 +0,0 @@
-import { warning } from '../../utils/errors.js';
-import { secondsToMilliseconds } from '../../utils/time-conversion.js';
-import { instantAnimationState } from '../../utils/use-instant-transition-state.js';
-import { createAcceleratedAnimation } from '../animators/waapi/create-accelerated-animation.js';
-import { createInstantAnimation } from '../animators/instant.js';
-import { getDefaultTransition } from '../utils/default-transitions.js';
-import { isAnimatable } from '../utils/is-animatable.js';
-import { getKeyframes } from '../utils/keyframes.js';
-import { getValueTransition, isTransitionDefined } from '../utils/transitions.js';
-import { animateValue } from '../animators/js/index.js';
-
-const animateMotionValue = (valueName, value, target, transition = {}) => {
-    return (onComplete) => {
-        const valueTransition = getValueTransition(transition, valueName) || {};
-        /**
-         * Most transition values are currently completely overwritten by value-specific
-         * transitions. In the future it'd be nicer to blend these transitions. But for now
-         * delay actually does inherit from the root transition if not value-specific.
-         */
-        const delay = valueTransition.delay || transition.delay || 0;
-        /**
-         * Elapsed isn't a public transition option but can be passed through from
-         * optimized appear effects in milliseconds.
-         */
-        let { elapsed = 0 } = transition;
-        elapsed = elapsed - secondsToMilliseconds(delay);
-        const keyframes = getKeyframes(value, valueName, target, valueTransition);
-        /**
-         * Check if we're able to animate between the start and end keyframes,
-         * and throw a warning if we're attempting to animate between one that's
-         * animatable and another that isn't.
-         */
-        const originKeyframe = keyframes[0];
-        const targetKeyframe = keyframes[keyframes.length - 1];
-        const isOriginAnimatable = isAnimatable(valueName, originKeyframe);
-        const isTargetAnimatable = isAnimatable(valueName, targetKeyframe);
-        warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${valueName} from "${originKeyframe}" to "${targetKeyframe}". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \`style\` property.`);
-        let options = {
-            keyframes,
-            velocity: value.getVelocity(),
-            ease: "easeOut",
-            ...valueTransition,
-            delay: -elapsed,
-            onUpdate: (v) => {
-                value.set(v);
-                valueTransition.onUpdate && valueTransition.onUpdate(v);
-            },
-            onComplete: () => {
-                onComplete();
-                valueTransition.onComplete && valueTransition.onComplete();
-            },
-        };
-        /**
-         * If there's no transition defined for this value, we can generate
-         * unqiue transition settings for this value.
-         */
-        if (!isTransitionDefined(valueTransition)) {
-            options = {
-                ...options,
-                ...getDefaultTransition(valueName, options),
-            };
-        }
-        /**
-         * Both WAAPI and our internal animation functions use durations
-         * as defined by milliseconds, while our external API defines them
-         * as seconds.
-         */
-        if (options.duration) {
-            options.duration = secondsToMilliseconds(options.duration);
-        }
-        if (options.repeatDelay) {
-            options.repeatDelay = secondsToMilliseconds(options.repeatDelay);
-        }
-        if (!isOriginAnimatable ||
-            !isTargetAnimatable ||
-            instantAnimationState.current ||
-            valueTransition.type === false) {
-            /**
-             * If we can't animate this value, or the global instant animation flag is set,
-             * or this is simply defined as an instant transition, return an instant transition.
-             */
-            return createInstantAnimation(options);
-        }
-        /**
-         * Animate via WAAPI if possible.
-         */
-        if (value.owner &&
-            value.owner.current instanceof HTMLElement &&
-            !value.owner.getProps().onUpdate) {
-            const acceleratedAnimation = createAcceleratedAnimation(value, valueName, options);
-            if (acceleratedAnimation)
-                return acceleratedAnimation;
-        }
-        /**
-         * If we didn't create an accelerated animation, create a JS animation
-         */
-        return animateValue(options);
-    };
-};
-
-export { animateMotionValue };

package/esm/node_modules/framer-motion/dist/es/animation/interfaces/single-value.js

@@ -1,11 +0,0 @@
-import { animateMotionValue } from './motion-value.js';
-import { motionValue } from '../../value/index.js';
-import { isMotionValue } from '../../value/utils/is-motion-value.js';
-
-function animateSingleValue(value, keyframes, options) {
-    const motionValue$1 = isMotionValue(value) ? value : motionValue(value);
-    motionValue$1.start(animateMotionValue("", motionValue$1, keyframes, options));
-    return motionValue$1.animation;
-}
-
-export { animateSingleValue };

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

@@ -1,71 +0,0 @@
-import { transformProps } from '../../render/html/utils/transform.js';
-import { optimizedAppearDataAttribute } from '../optimized-appear/data-id.js';
-import { animateMotionValue } from './motion-value.js';
-import { isWillChangeMotionValue } from '../../value/use-will-change/is.js';
-import { setTarget } from '../../render/utils/setters.js';
-import { frame } from '../../frameloop/frame.js';
-
-/**
- * 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, definition, { delay = 0, transitionOverride, type } = {}) {
-    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = visualElement.makeTargetAnimatable(definition);
-    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);
-        const valueTarget = target[key];
-        if (!value ||
-            valueTarget === undefined ||
-            (animationTypeState &&
-                shouldBlockAnimation(animationTypeState, key))) {
-            continue;
-        }
-        const valueTransition = {
-            delay,
-            elapsed: 0,
-            ...transition,
-        };
-        /**
-         * If this is the first time a value is being animated, check
-         * to see if we're handling off from an existing animation.
-         */
-        if (window.HandoffAppearAnimations && !value.hasAnimated) {
-            const appearId = visualElement.getProps()[optimizedAppearDataAttribute];
-            if (appearId) {
-                valueTransition.elapsed = window.HandoffAppearAnimations(appearId, key, value, frame);
-                valueTransition.syncStart = true;
-            }
-        }
-        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)
-            ? { type: false }
-            : valueTransition));
-        const animation = value.animation;
-        if (isWillChangeMotionValue(willChange)) {
-            willChange.add(key);
-            animation.then(() => willChange.remove(key));
-        }
-        animations.push(animation);
-    }
-    if (transitionEnd) {
-        Promise.all(animations).then(() => {
-            transitionEnd && setTarget(visualElement, transitionEnd);
-        });
-    }
-    return animations;
-}
-
-export { animateTarget };

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

@@ -1,63 +0,0 @@
-import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.js';
-import { animateTarget } from './visual-element-target.js';
-
-function animateVariant(visualElement, variant, options = {}) {
-    const resolved = resolveVariant(visualElement, variant, options.custom);
-    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/esm/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.js

@@ -1,24 +0,0 @@
-import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.js';
-import { animateTarget } from './visual-element-target.js';
-import { animateVariant } from './visual-element-variant.js';
-
-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(() => visualElement.notify("AnimationComplete", definition));
-}
-
-export { animateVisualElement };

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

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

package/esm/node_modules/framer-motion/dist/es/animation/utils/default-transitions.js

@@ -1,40 +0,0 @@
-import { transformProps } from '../../render/html/utils/transform.js';
-
-const underDampedSpring = {
-    type: "spring",
-    stiffness: 500,
-    damping: 25,
-    restSpeed: 10,
-};
-const criticallyDampedSpring = (target) => ({
-    type: "spring",
-    stiffness: 550,
-    damping: target === 0 ? 2 * Math.sqrt(550) : 30,
-    restSpeed: 10,
-});
-const keyframesTransition = {
-    type: "keyframes",
-    duration: 0.8,
-};
-/**
- * Default easing curve is a slightly shallower version of
- * the default browser easing curve.
- */
-const ease = {
-    type: "keyframes",
-    ease: [0.25, 0.1, 0.35, 1],
-    duration: 0.3,
-};
-const getDefaultTransition = (valueKey, { keyframes }) => {
-    if (keyframes.length > 2) {
-        return keyframesTransition;
-    }
-    else if (transformProps.has(valueKey)) {
-        return valueKey.startsWith("scale")
-            ? criticallyDampedSpring(keyframes[1])
-            : underDampedSpring;
-    }
-    return ease;
-};
-
-export { getDefaultTransition };

package/esm/node_modules/framer-motion/dist/es/animation/utils/is-animatable.js

@@ -1,30 +0,0 @@
-import { complex } from '../../value/types/complex/index.js';
-
-/**
- * Check if a value is animatable. Examples:
- *
- * ✅: 100, "100px", "#fff"
- * ❌: "block", "url(2.jpg)"
- * @param value
- *
- * @internal
- */
-const isAnimatable = (key, value) => {
-    // If the list of keys tat might be non-animatable grows, replace with Set
-    if (key === "zIndex")
-        return false;
-    // If it's a number or a keyframes array, we can animate it. We might at some point
-    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,
-    // but for now lets leave it like this for performance reasons
-    if (typeof value === "number" || Array.isArray(value))
-        return true;
-    if (typeof value === "string" && // It's animatable if we have a string
-        (complex.test(value) || value === "0") && // And it contains numbers and/or colors
-        !value.startsWith("url(") // Unless it starts with "url("
-    ) {
-        return true;
-    }
-    return false;
-};
-
-export { isAnimatable };

package/esm/node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.js

@@ -1,5 +0,0 @@
-function isAnimationControls(v) {
-    return typeof v === "object" && typeof v.start === "function";
-}
-
-export { isAnimationControls };

package/esm/node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.js

@@ -1,5 +0,0 @@
-const isKeyframesTarget = (v) => {
-    return Array.isArray(v);
-};
-
-export { isKeyframesTarget };