motion 12.18.1 → 12.19.0

package/dist/es/motion-dom/dist/es/animation/NativeAnimation.mjs

@@ -1,158 +0,0 @@
-import { setStyle } from '../render/dom/style-set.mjs';
-import { supportsScrollTimeline } from '../utils/supports/scroll-timeline.mjs';
-import { getFinalKeyframe } from './keyframes/get-final.mjs';
-import { WithPromise } from './utils/WithPromise.mjs';
-import { startWaapiAnimation } from './waapi/start-waapi-animation.mjs';
-import { applyGeneratorOptions } from './waapi/utils/apply-generator.mjs';
-import { invariant } from '../../../../motion-utils/dist/es/errors.mjs';
-import { millisecondsToSeconds, secondsToMilliseconds } from '../../../../motion-utils/dist/es/time-conversion.mjs';
-import { noop } from '../../../../motion-utils/dist/es/noop.mjs';
-
-/**
- * NativeAnimation implements AnimationPlaybackControls for the browser's Web Animations API.
- */
-class NativeAnimation extends WithPromise {
-    constructor(options) {
-        super();
-        this.finishedTime = null;
-        this.isStopped = false;
-        if (!options)
-            return;
-        const { element, name, keyframes, pseudoElement, allowFlatten = false, finalKeyframe, onComplete, } = options;
-        this.isPseudoElement = Boolean(pseudoElement);
-        this.allowFlatten = allowFlatten;
-        this.options = options;
-        invariant(typeof options.type !== "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "motion"?`);
-        const transition = applyGeneratorOptions(options);
-        this.animation = startWaapiAnimation(element, name, keyframes, transition, pseudoElement);
-        if (transition.autoplay === false) {
-            this.animation.pause();
-        }
-        this.animation.onfinish = () => {
-            this.finishedTime = this.time;
-            if (!pseudoElement) {
-                const keyframe = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);
-                if (this.updateMotionValue) {
-                    this.updateMotionValue(keyframe);
-                }
-                else {
-                    /**
-                     * If we can, we want to commit the final style as set by the user,
-                     * rather than the computed keyframe value supplied by the animation.
-                     */
-                    setStyle(element, name, keyframe);
-                }
-                this.animation.cancel();
-            }
-            onComplete?.();
-            this.notifyFinished();
-        };
-    }
-    play() {
-        if (this.isStopped)
-            return;
-        this.animation.play();
-        if (this.state === "finished") {
-            this.updateFinished();
-        }
-    }
-    pause() {
-        this.animation.pause();
-    }
-    complete() {
-        this.animation.finish?.();
-    }
-    cancel() {
-        try {
-            this.animation.cancel();
-        }
-        catch (e) { }
-    }
-    stop() {
-        if (this.isStopped)
-            return;
-        this.isStopped = true;
-        const { state } = this;
-        if (state === "idle" || state === "finished") {
-            return;
-        }
-        if (this.updateMotionValue) {
-            this.updateMotionValue();
-        }
-        else {
-            this.commitStyles();
-        }
-        if (!this.isPseudoElement)
-            this.cancel();
-    }
-    /**
-     * WAAPI doesn't natively have any interruption capabilities.
-     *
-     * In this method, we commit styles back to the DOM before cancelling
-     * the animation.
-     *
-     * This is designed to be overridden by NativeAnimationExtended, which
-     * will create a renderless JS animation and sample it twice to calculate
-     * its current value, "previous" value, and therefore allow
-     * Motion to also correctly calculate velocity for any subsequent animation
-     * while deferring the commit until the next animation frame.
-     */
-    commitStyles() {
-        if (!this.isPseudoElement) {
-            this.animation.commitStyles?.();
-        }
-    }
-    get duration() {
-        const duration = this.animation.effect?.getComputedTiming?.().duration || 0;
-        return millisecondsToSeconds(Number(duration));
-    }
-    get time() {
-        return millisecondsToSeconds(Number(this.animation.currentTime) || 0);
-    }
-    set time(newTime) {
-        this.finishedTime = null;
-        this.animation.currentTime = secondsToMilliseconds(newTime);
-    }
-    /**
-     * The playback speed of the animation.
-     * 1 = normal speed, 2 = double speed, 0.5 = half speed.
-     */
-    get speed() {
-        return this.animation.playbackRate;
-    }
-    set speed(newSpeed) {
-        // Allow backwards playback after finishing
-        if (newSpeed < 0)
-            this.finishedTime = null;
-        this.animation.playbackRate = newSpeed;
-    }
-    get state() {
-        return this.finishedTime !== null
-            ? "finished"
-            : this.animation.playState;
-    }
-    get startTime() {
-        return Number(this.animation.startTime);
-    }
-    set startTime(newStartTime) {
-        this.animation.startTime = newStartTime;
-    }
-    /**
-     * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
-     */
-    attachTimeline({ timeline, observe }) {
-        if (this.allowFlatten) {
-            this.animation.effect?.updateTiming({ easing: "linear" });
-        }
-        this.animation.onfinish = null;
-        if (timeline && supportsScrollTimeline()) {
-            this.animation.timeline = timeline;
-            return noop;
-        }
-        else {
-            return observe(this);
-        }
-    }
-}
-
-export { NativeAnimation };

package/dist/es/motion-dom/dist/es/animation/NativeAnimationExtended.mjs

@@ -1,65 +0,0 @@
-import { JSAnimation } from './JSAnimation.mjs';
-import { NativeAnimation } from './NativeAnimation.mjs';
-import { replaceTransitionType } from './utils/replace-transition-type.mjs';
-import { replaceStringEasing } from './waapi/utils/unsupported-easing.mjs';
-import { secondsToMilliseconds } from '../../../../motion-utils/dist/es/time-conversion.mjs';
-
-/**
- * 10ms is chosen here as it strikes a balance between smooth
- * results (more than one keyframe per frame at 60fps) and
- * keyframe quantity.
- */
-const sampleDelta = 10; //ms
-class NativeAnimationExtended extends NativeAnimation {
-    constructor(options) {
-        /**
-         * The base NativeAnimation function only supports a subset
-         * of Motion easings, and WAAPI also only supports some
-         * easing functions via string/cubic-bezier definitions.
-         *
-         * This function replaces those unsupported easing functions
-         * with a JS easing function. This will later get compiled
-         * to a linear() easing function.
-         */
-        replaceStringEasing(options);
-        /**
-         * Ensure we replace the transition type with a generator function
-         * before passing to WAAPI.
-         *
-         * TODO: Does this have a better home? It could be shared with
-         * JSAnimation.
-         */
-        replaceTransitionType(options);
-        super(options);
-        if (options.startTime) {
-            this.startTime = options.startTime;
-        }
-        this.options = options;
-    }
-    /**
-     * WAAPI doesn't natively have any interruption capabilities.
-     *
-     * Rather than read commited styles back out of the DOM, we can
-     * create a renderless JS animation and sample it twice to calculate
-     * its current value, "previous" value, and therefore allow
-     * Motion to calculate velocity for any subsequent animation.
-     */
-    updateMotionValue(value) {
-        const { motionValue, onUpdate, onComplete, element, ...options } = this.options;
-        if (!motionValue)
-            return;
-        if (value !== undefined) {
-            motionValue.set(value);
-            return;
-        }
-        const sampleAnimation = new JSAnimation({
-            ...options,
-            autoplay: false,
-        });
-        const sampleTime = secondsToMilliseconds(this.finishedTime ?? this.time);
-        motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);
-        sampleAnimation.stop();
-    }
-}
-
-export { NativeAnimationExtended };

package/dist/es/motion-dom/dist/es/animation/NativeAnimationWrapper.mjs

@@ -1,14 +0,0 @@
-import { NativeAnimation } from './NativeAnimation.mjs';
-
-class NativeAnimationWrapper extends NativeAnimation {
-    constructor(animation) {
-        super();
-        this.animation = animation;
-        animation.onfinish = () => {
-            this.finishedTime = this.time;
-            this.notifyFinished();
-        };
-    }
-}
-
-export { NativeAnimationWrapper };

package/dist/es/motion-dom/dist/es/animation/drivers/frame.mjs

@@ -1,17 +0,0 @@
-import { time } from '../../frameloop/sync-time.mjs';
-import { frame, cancelFrame, frameData } from '../../frameloop/frame.mjs';
-
-const frameloopDriver = (update) => {
-    const passTimestamp = ({ timestamp }) => update(timestamp);
-    return {
-        start: (keepAlive = true) => frame.update(passTimestamp, keepAlive),
-        stop: () => cancelFrame(passTimestamp),
-        /**
-         * If we're processing this frame we can use the
-         * framelocked timestamp to keep things in sync.
-         */
-        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),
-    };
-};
-
-export { frameloopDriver };

package/dist/es/motion-dom/dist/es/animation/generators/inertia.mjs

@@ -1,87 +0,0 @@
-import { spring } from './spring/index.mjs';
-import { calcGeneratorVelocity } from './utils/velocity.mjs';
-
-function inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {
-    const origin = keyframes[0];
-    const state = {
-        done: false,
-        value: origin,
-    };
-    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);
-    const nearestBoundary = (v) => {
-        if (min === undefined)
-            return max;
-        if (max === undefined)
-            return min;
-        return Math.abs(min - v) < Math.abs(max - v) ? min : max;
-    };
-    let amplitude = power * velocity;
-    const ideal = origin + amplitude;
-    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);
-    /**
-     * If the target has changed we need to re-calculate the amplitude, otherwise
-     * the animation will start from the wrong position.
-     */
-    if (target !== ideal)
-        amplitude = target - origin;
-    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);
-    const calcLatest = (t) => target + calcDelta(t);
-    const applyFriction = (t) => {
-        const delta = calcDelta(t);
-        const latest = calcLatest(t);
-        state.done = Math.abs(delta) <= restDelta;
-        state.value = state.done ? target : latest;
-    };
-    /**
-     * Ideally this would resolve for t in a stateless way, we could
-     * do that by always precalculating the animation but as we know
-     * this will be done anyway we can assume that spring will
-     * be discovered during that.
-     */
-    let timeReachedBoundary;
-    let spring$1;
-    const checkCatchBoundary = (t) => {
-        if (!isOutOfBounds(state.value))
-            return;
-        timeReachedBoundary = t;
-        spring$1 = spring({
-            keyframes: [state.value, nearestBoundary(state.value)],
-            velocity: calcGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000
-            damping: bounceDamping,
-            stiffness: bounceStiffness,
-            restDelta,
-            restSpeed,
-        });
-    };
-    checkCatchBoundary(0);
-    return {
-        calculatedDuration: null,
-        next: (t) => {
-            /**
-             * We need to resolve the friction to figure out if we need a
-             * spring but we don't want to do this twice per frame. So here
-             * we flag if we updated for this frame and later if we did
-             * we can skip doing it again.
-             */
-            let hasUpdatedFrame = false;
-            if (!spring$1 && timeReachedBoundary === undefined) {
-                hasUpdatedFrame = true;
-                applyFriction(t);
-                checkCatchBoundary(t);
-            }
-            /**
-             * If we have a spring and the provided t is beyond the moment the friction
-             * animation crossed the min/max boundary, use the spring.
-             */
-            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {
-                return spring$1.next(t - timeReachedBoundary);
-            }
-            else {
-                !hasUpdatedFrame && applyFriction(t);
-                return state;
-            }
-        },
-    };
-}
-
-export { inertia };

package/dist/es/motion-dom/dist/es/animation/generators/keyframes.mjs

@@ -1,51 +0,0 @@
-import { interpolate } from '../../utils/interpolate.mjs';
-import { defaultOffset } from '../keyframes/offsets/default.mjs';
-import { convertOffsetToTimes } from '../keyframes/offsets/time.mjs';
-import { easeInOut } from '../../../../../motion-utils/dist/es/easing/ease.mjs';
-import { isEasingArray } from '../../../../../motion-utils/dist/es/easing/utils/is-easing-array.mjs';
-import { easingDefinitionToFunction } from '../../../../../motion-utils/dist/es/easing/utils/map.mjs';
-
-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/dist/es/motion-dom/dist/es/animation/generators/spring/defaults.mjs

@@ -1,27 +0,0 @@
-const springDefaults = {
-    // Default spring physics
-    stiffness: 100,
-    damping: 10,
-    mass: 1.0,
-    velocity: 0.0,
-    // Default duration/bounce-based options
-    duration: 800, // in ms
-    bounce: 0.3,
-    visualDuration: 0.3, // in seconds
-    // Rest thresholds
-    restSpeed: {
-        granular: 0.01,
-        default: 2,
-    },
-    restDelta: {
-        granular: 0.005,
-        default: 0.5,
-    },
-    // Limits
-    minDuration: 0.01, // in seconds
-    maxDuration: 10.0, // in seconds
-    minDamping: 0.05,
-    maxDamping: 1,
-};
-
-export { springDefaults };

package/dist/es/motion-dom/dist/es/animation/generators/spring/find.mjs

@@ -1,86 +0,0 @@
-import { springDefaults } from './defaults.mjs';
-import { warning } from '../../../../../../motion-utils/dist/es/errors.mjs';
-import { secondsToMilliseconds, millisecondsToSeconds } from '../../../../../../motion-utils/dist/es/time-conversion.mjs';
-import { clamp } from '../../../../../../motion-utils/dist/es/clamp.mjs';
-
-const safeMin = 0.001;
-function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {
-    let envelope;
-    let derivative;
-    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less");
-    let dampingRatio = 1 - bounce;
-    /**
-     * Restrict dampingRatio and duration to within acceptable ranges.
-     */
-    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
-    duration = clamp(springDefaults.minDuration, springDefaults.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: springDefaults.stiffness,
-            damping: springDefaults.damping,
-            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 };

package/dist/es/motion-dom/dist/es/animation/generators/spring/index.mjs

@@ -1,176 +0,0 @@
-import { generateLinearEasing } from '../../waapi/utils/linear.mjs';
-import { calcGeneratorDuration, maxGeneratorDuration } from '../utils/calc-duration.mjs';
-import { createGeneratorEasing } from '../utils/create-generator-easing.mjs';
-import { calcGeneratorVelocity } from '../utils/velocity.mjs';
-import { springDefaults } from './defaults.mjs';
-import { findSpring, calcAngularFreq } from './find.mjs';
-import { millisecondsToSeconds, secondsToMilliseconds } from '../../../../../../motion-utils/dist/es/time-conversion.mjs';
-import { clamp } from '../../../../../../motion-utils/dist/es/clamp.mjs';
-
-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: springDefaults.velocity,
-        stiffness: springDefaults.stiffness,
-        damping: springDefaults.damping,
-        mass: springDefaults.mass,
-        isResolvedFromDuration: false,
-        ...options,
-    };
-    // stiffness/damping/mass overrides duration/bounce
-    if (!isSpringType(options, physicsKeys) &&
-        isSpringType(options, durationKeys)) {
-        if (options.visualDuration) {
-            const visualDuration = options.visualDuration;
-            const root = (2 * Math.PI) / (visualDuration * 1.2);
-            const stiffness = root * root;
-            const damping = 2 *
-                clamp(0.05, 1, 1 - (options.bounce || 0)) *
-                Math.sqrt(stiffness);
-            springOptions = {
-                ...springOptions,
-                mass: springDefaults.mass,
-                stiffness,
-                damping,
-            };
-        }
-        else {
-            const derived = findSpring(options);
-            springOptions = {
-                ...springOptions,
-                ...derived,
-                mass: springDefaults.mass,
-            };
-            springOptions.isResolvedFromDuration = true;
-        }
-    }
-    return springOptions;
-}
-function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
-    const options = typeof optionsOrVisualDuration !== "object"
-        ? {
-            visualDuration: optionsOrVisualDuration,
-            keyframes: [0, 1],
-            bounce,
-        }
-        : optionsOrVisualDuration;
-    let { restSpeed, restDelta } = options;
-    const origin = options.keyframes[0];
-    const target = options.keyframes[options.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, duration, velocity, isResolvedFromDuration, } = getSpringOptions({
-        ...options,
-        velocity: -millisecondsToSeconds(options.velocity || 0),
-    });
-    const initialVelocity = 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
-        ? springDefaults.restSpeed.granular
-        : springDefaults.restSpeed.default);
-    restDelta || (restDelta = isGranularScale
-        ? springDefaults.restDelta.granular
-        : springDefaults.restDelta.default);
-    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);
-        };
-    }
-    const generator = {
-        calculatedDuration: isResolvedFromDuration ? duration || null : null,
-        next: (t) => {
-            const current = resolveSpring(t);
-            if (!isResolvedFromDuration) {
-                let currentVelocity = t === 0 ? initialVelocity : 0.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 =
-                        t === 0
-                            ? secondsToMilliseconds(initialVelocity)
-                            : calcGeneratorVelocity(resolveSpring, t, current);
-                }
-                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;
-        },
-        toString: () => {
-            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
-            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);
-            return calculatedDuration + "ms " + easing;
-        },
-        toTransition: () => { },
-    };
-    return generator;
-}
-spring.applyToOptions = (options) => {
-    const generatorOptions = createGeneratorEasing(options, 100, spring);
-    options.ease = generatorOptions.ease;
-    options.duration = secondsToMilliseconds(generatorOptions.duration);
-    options.type = "keyframes";
-    return options;
-};
-
-export { spring };