@123usmanhaider321/ui 0.1.0 → 0.1.8

package/dist/node_modules/motion-dom/dist/es/animation/JSAnimation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"JSAnimation.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/JSAnimation.mjs"],"sourcesContent":["import { invariant, pipe, clamp, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { activeAnimations } from '../stats/animation-count.mjs';\nimport { mix } from '../utils/mix/index.mjs';\nimport { frameloopDriver } from './drivers/frame.mjs';\nimport { inertia } from './generators/inertia.mjs';\nimport { keyframes } from './generators/keyframes.mjs';\nimport { calcGeneratorDuration } from './generators/utils/calc-duration.mjs';\nimport { getGeneratorVelocity } from './generators/utils/velocity.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\n\nconst percentToProgress = (percent) => percent / 100;\nclass JSAnimation extends WithPromise {\n    constructor(options) {\n        super();\n        this.state = \"idle\";\n        this.startTime = null;\n        this.isStopped = false;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * Reusable state object for the delay phase to avoid\n         * allocating a new object every frame.\n         */\n        this.delayState = {\n            done: false,\n            value: undefined,\n        };\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            const { motionValue } = this.options;\n            if (motionValue && motionValue.updatedAt !== time.now()) {\n                this.tick(time.now());\n            }\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            this.options.onStop?.();\n        };\n        activeAnimations.mainThread++;\n        this.options = options;\n        this.initAnimation();\n        this.play();\n        if (options.autoplay === false)\n            this.pause();\n    }\n    initAnimation() {\n        const { options } = this;\n        replaceTransitionType(options);\n        const { type = keyframes, repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = options;\n        let { keyframes: keyframes$1 } = options;\n        const generatorFactory = type || keyframes;\n        if (process.env.NODE_ENV !== \"production\" &&\n            generatorFactory !== keyframes) {\n            invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`, \"spring-two-frames\");\n        }\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            this.mixKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            this.mirroredGenerator = generatorFactory({\n                ...options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\n        /**\n         * If duration is undefined and we have repeat options,\n         * we need to calculate a duration from the generator.\n         *\n         * We set it to the generator itself to cache the duration.\n         * Any timeline resolver will need to have already precalculated\n         * the duration by this step.\n         */\n        if (generator.calculatedDuration === null) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        this.calculatedDuration = calculatedDuration;\n        this.resolvedDuration = calculatedDuration + repeatDelay;\n        this.totalDuration = this.resolvedDuration * (repeat + 1) - repeatDelay;\n        this.generator = generator;\n    }\n    updateTime(timestamp) {\n        const animationTime = Math.round(timestamp - this.startTime) * this.playbackSpeed;\n        // Update currentTime\n        if (this.holdTime !== null) {\n            this.currentTime = this.holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            this.currentTime = animationTime;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { generator, totalDuration, mixKeyframes, mirroredGenerator, resolvedDuration, calculatedDuration, } = this;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay = 0, keyframes, repeat, repeatType, repeatDelay, type, onUpdate, finalKeyframe, } = this.options;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else {\n            this.updateTime(timestamp);\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.playbackSpeed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.playbackSpeed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        let state;\n        if (isInDelayPhase) {\n            this.delayState.value = keyframes[0];\n            state = this.delayState;\n        }\n        else {\n            state = frameGenerator.next(elapsed);\n        }\n        if (mixKeyframes && !isInDelayPhase) {\n            state.value = mixKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.playbackSpeed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        // TODO: The exception for inertia could be cleaner here\n        if (isAnimationFinished && type !== inertia) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.finished.then(resolve, reject);\n    }\n    get duration() {\n        return millisecondsToSeconds(this.calculatedDuration);\n    }\n    get iterationDuration() {\n        const { delay = 0 } = this.options || {};\n        return this.duration + millisecondsToSeconds(delay);\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.startTime === null ||\n            this.holdTime !== null ||\n            this.playbackSpeed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.playbackSpeed;\n        }\n        if (this.driver) {\n            this.driver.start(false);\n        }\n        else {\n            this.startTime = 0;\n            this.state = \"paused\";\n            this.holdTime = newTime;\n            this.tick(newTime);\n        }\n    }\n    /**\n     * Returns the generator's velocity at the current time in units/second.\n     * Uses the analytical derivative when available (springs), avoiding\n     * the MotionValue's frame-dependent velocity estimation.\n     */\n    getGeneratorVelocity() {\n        const t = this.currentTime;\n        if (t <= 0)\n            return this.options.velocity || 0;\n        if (this.generator.velocity) {\n            return this.generator.velocity(t);\n        }\n        // Fallback: finite difference\n        const current = this.generator.next(t).value;\n        return getGeneratorVelocity((s) => this.generator.next(s).value, t, current);\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        if (hasChanged && this.driver) {\n            this.updateTime(time.now());\n        }\n        this.playbackSpeed = newSpeed;\n        if (hasChanged && this.driver) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        this.options.onPlay?.();\n        const now = this.driver.now();\n        if (this.state === \"finished\") {\n            this.updateFinished();\n            this.startTime = now;\n        }\n        else if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime ?? now;\n        }\n        if (this.state === \"finished\" && this.speed < 0) {\n            this.startTime += this.calculatedDuration;\n        }\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        this.state = \"paused\";\n        this.updateTime(time.now());\n        this.holdTime = this.currentTime;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.notifyFinished();\n        this.teardown();\n        this.state = \"finished\";\n        this.options.onComplete?.();\n    }\n    cancel() {\n        this.holdTime = null;\n        this.startTime = 0;\n        this.tick(0);\n        this.teardown();\n        this.options.onCancel?.();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.startTime = this.holdTime = null;\n        activeAnimations.mainThread--;\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(sampleTime) {\n        this.startTime = 0;\n        return this.tick(sampleTime, true);\n    }\n    attachTimeline(timeline) {\n        if (this.options.allowFlatten) {\n            this.options.type = \"keyframes\";\n            this.options.ease = \"linear\";\n            this.initAnimation();\n        }\n        this.driver?.stop();\n        return timeline.observe(this);\n    }\n}\n// Legacy function support\nfunction animateValue(options) {\n    return new JSAnimation(options);\n}\n\nexport { JSAnimation, animateValue };\n//# sourceMappingURL=JSAnimation.mjs.map\n"],"names":["keyframes"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation.js

@@ -1,165 +0,0 @@
-import { setStyle } from "../render/dom/style-set.js";
-import { supportsScrollTimeline } from "../utils/supports/scroll-timeline.js";
-import { getFinalKeyframe } from "./keyframes/get-final.js";
-import { WithPromise } from "./utils/WithPromise.js";
-import { startWaapiAnimation } from "./waapi/start-waapi-animation.js";
-import { applyGeneratorOptions } from "./waapi/utils/apply-generator.js";
-import { invariant } from "../../../../motion-utils/dist/es/errors.js";
-import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../motion-utils/dist/es/time-conversion.js";
-import { noop } from "../../../../motion-utils/dist/es/noop.js";
-class NativeAnimation extends WithPromise {
-  constructor(options) {
-    super();
-    this.finishedTime = null;
-    this.isStopped = false;
-    this.manualStartTime = null;
-    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", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
-    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);
-        }
-        setStyle(element, name, keyframe);
-        this.animation.cancel();
-      }
-      onComplete == null ? void 0 : onComplete();
-      this.notifyFinished();
-    };
-  }
-  play() {
-    if (this.isStopped)
-      return;
-    this.manualStartTime = null;
-    this.animation.play();
-    if (this.state === "finished") {
-      this.updateFinished();
-    }
-  }
-  pause() {
-    this.animation.pause();
-  }
-  complete() {
-    var _a, _b;
-    (_b = (_a = this.animation).finish) == null ? void 0 : _b.call(_a);
-  }
-  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() {
-    var _a, _b, _c;
-    const element = (_a = this.options) == null ? void 0 : _a.element;
-    if (!this.isPseudoElement && (element == null ? void 0 : element.isConnected)) {
-      (_c = (_b = this.animation).commitStyles) == null ? void 0 : _c.call(_b);
-    }
-  }
-  get duration() {
-    var _a, _b;
-    const duration = ((_b = (_a = this.animation.effect) == null ? void 0 : _a.getComputedTiming) == null ? void 0 : _b.call(_a).duration) || 0;
-    return millisecondsToSeconds(Number(duration));
-  }
-  get iterationDuration() {
-    const { delay = 0 } = this.options || {};
-    return this.duration + millisecondsToSeconds(delay);
-  }
-  get time() {
-    return millisecondsToSeconds(Number(this.animation.currentTime) || 0);
-  }
-  set time(newTime) {
-    const wasFinished = this.finishedTime !== null;
-    this.manualStartTime = null;
-    this.finishedTime = null;
-    this.animation.currentTime = secondsToMilliseconds(newTime);
-    if (wasFinished) {
-      this.animation.pause();
-    }
-  }
-  /**
-   * 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) {
-    if (newSpeed < 0)
-      this.finishedTime = null;
-    this.animation.playbackRate = newSpeed;
-  }
-  get state() {
-    return this.finishedTime !== null ? "finished" : this.animation.playState;
-  }
-  get startTime() {
-    return this.manualStartTime ?? Number(this.animation.startTime);
-  }
-  set startTime(newStartTime) {
-    this.manualStartTime = this.animation.startTime = newStartTime;
-  }
-  /**
-   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
-   */
-  attachTimeline({ timeline, rangeStart, rangeEnd, observe }) {
-    var _a;
-    if (this.allowFlatten) {
-      (_a = this.animation.effect) == null ? void 0 : _a.updateTiming({ easing: "linear" });
-    }
-    this.animation.onfinish = null;
-    if (timeline && supportsScrollTimeline()) {
-      this.animation.timeline = timeline;
-      if (rangeStart)
-        this.animation.rangeStart = rangeStart;
-      if (rangeEnd)
-        this.animation.rangeEnd = rangeEnd;
-      return noop;
-    } else {
-      return observe(this);
-    }
-  }
-}
-export {
-  NativeAnimation
-};
-//# sourceMappingURL=NativeAnimation.js.map

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativeAnimation.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs"],"sourcesContent":["import { invariant, millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { setStyle } from '../render/dom/style-set.mjs';\nimport { supportsScrollTimeline } from '../utils/supports/scroll-timeline.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\nimport { startWaapiAnimation } from './waapi/start-waapi-animation.mjs';\nimport { applyGeneratorOptions } from './waapi/utils/apply-generator.mjs';\n\n/**\n * NativeAnimation implements AnimationPlaybackControls for the browser's Web Animations API.\n */\nclass NativeAnimation extends WithPromise {\n    constructor(options) {\n        super();\n        this.finishedTime = null;\n        this.isStopped = false;\n        /**\n         * Tracks a manually-set start time that takes precedence over WAAPI's\n         * dynamic startTime. This is cleared when play() or time setter is called,\n         * allowing WAAPI to take over timing.\n         */\n        this.manualStartTime = null;\n        if (!options)\n            return;\n        const { element, name, keyframes, pseudoElement, allowFlatten = false, finalKeyframe, onComplete, } = options;\n        this.isPseudoElement = Boolean(pseudoElement);\n        this.allowFlatten = allowFlatten;\n        this.options = options;\n        invariant(typeof options.type !== \"string\", `Mini animate() doesn't support \"type\" as a string.`, \"mini-spring\");\n        const transition = applyGeneratorOptions(options);\n        this.animation = startWaapiAnimation(element, name, keyframes, transition, pseudoElement);\n        if (transition.autoplay === false) {\n            this.animation.pause();\n        }\n        this.animation.onfinish = () => {\n            this.finishedTime = this.time;\n            if (!pseudoElement) {\n                const keyframe = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);\n                if (this.updateMotionValue) {\n                    this.updateMotionValue(keyframe);\n                }\n                /**\n                 * If we can, we want to commit the final style as set by the user,\n                 * rather than the computed keyframe value supplied by the animation.\n                 * We always do this, even when a motion value is present, to prevent\n                 * a visual flash in Firefox where the WAAPI animation's fill is removed\n                 * during cancel() before the scheduled render can apply the correct value.\n                 */\n                setStyle(element, name, keyframe);\n                this.animation.cancel();\n            }\n            onComplete?.();\n            this.notifyFinished();\n        };\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        this.manualStartTime = null;\n        this.animation.play();\n        if (this.state === \"finished\") {\n            this.updateFinished();\n        }\n    }\n    pause() {\n        this.animation.pause();\n    }\n    complete() {\n        this.animation.finish?.();\n    }\n    cancel() {\n        try {\n            this.animation.cancel();\n        }\n        catch (e) { }\n    }\n    stop() {\n        if (this.isStopped)\n            return;\n        this.isStopped = true;\n        const { state } = this;\n        if (state === \"idle\" || state === \"finished\") {\n            return;\n        }\n        if (this.updateMotionValue) {\n            this.updateMotionValue();\n        }\n        else {\n            this.commitStyles();\n        }\n        if (!this.isPseudoElement)\n            this.cancel();\n    }\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * In this method, we commit styles back to the DOM before cancelling\n     * the animation.\n     *\n     * This is designed to be overridden by NativeAnimationExtended, which\n     * will create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to also correctly calculate velocity for any subsequent animation\n     * while deferring the commit until the next animation frame.\n     */\n    commitStyles() {\n        const element = this.options?.element;\n        if (!this.isPseudoElement && element?.isConnected) {\n            this.animation.commitStyles?.();\n        }\n    }\n    get duration() {\n        const duration = this.animation.effect?.getComputedTiming?.().duration || 0;\n        return millisecondsToSeconds(Number(duration));\n    }\n    get iterationDuration() {\n        const { delay = 0 } = this.options || {};\n        return this.duration + millisecondsToSeconds(delay);\n    }\n    get time() {\n        return millisecondsToSeconds(Number(this.animation.currentTime) || 0);\n    }\n    set time(newTime) {\n        const wasFinished = this.finishedTime !== null;\n        this.manualStartTime = null;\n        this.finishedTime = null;\n        this.animation.currentTime = secondsToMilliseconds(newTime);\n        if (wasFinished) {\n            this.animation.pause();\n        }\n    }\n    /**\n     * The playback speed of the animation.\n     * 1 = normal speed, 2 = double speed, 0.5 = half speed.\n     */\n    get speed() {\n        return this.animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        // Allow backwards playback after finishing\n        if (newSpeed < 0)\n            this.finishedTime = null;\n        this.animation.playbackRate = newSpeed;\n    }\n    get state() {\n        return this.finishedTime !== null\n            ? \"finished\"\n            : this.animation.playState;\n    }\n    get startTime() {\n        return this.manualStartTime ?? Number(this.animation.startTime);\n    }\n    set startTime(newStartTime) {\n        this.manualStartTime = this.animation.startTime = newStartTime;\n    }\n    /**\n     * Attaches a timeline to the animation, for instance the `ScrollTimeline`.\n     */\n    attachTimeline({ timeline, rangeStart, rangeEnd, observe, }) {\n        if (this.allowFlatten) {\n            this.animation.effect?.updateTiming({ easing: \"linear\" });\n        }\n        this.animation.onfinish = null;\n        if (timeline && supportsScrollTimeline()) {\n            this.animation.timeline = timeline;\n            if (rangeStart)\n                this.animation.rangeStart = rangeStart;\n            if (rangeEnd)\n                this.animation.rangeEnd = rangeEnd;\n            return noop;\n        }\n        else {\n            return observe(this);\n        }\n    }\n}\n\nexport { NativeAnimation };\n//# sourceMappingURL=NativeAnimation.mjs.map\n"],"names":[],"mappings":";;;;;;;;;AAWA,MAAM,wBAAwB,YAAY;AAAA,EACtC,YAAY,SAAS;AACjB,UAAK;AACL,SAAK,eAAe;AACpB,SAAK,YAAY;AAMjB,SAAK,kBAAkB;AACvB,QAAI,CAAC;AACD;AACJ,UAAM,EAAE,SAAS,MAAM,WAAW,eAAe,eAAe,OAAO,eAAe,WAAU,IAAM;AACtG,SAAK,kBAAkB,QAAQ,aAAa;AAC5C,SAAK,eAAe;AACpB,SAAK,UAAU;AACf,cAAU,OAAO,QAAQ,SAAS,UAAU,sDAAsD,aAAa;AAC/G,UAAM,aAAa,sBAAsB,OAAO;AAChD,SAAK,YAAY,oBAAoB,SAAS,MAAM,WAAW,YAAY,aAAa;AACxF,QAAI,WAAW,aAAa,OAAO;AAC/B,WAAK,UAAU,MAAK;AAAA,IACxB;AACA,SAAK,UAAU,WAAW,MAAM;AAC5B,WAAK,eAAe,KAAK;AACzB,UAAI,CAAC,eAAe;AAChB,cAAM,WAAW,iBAAiB,WAAW,KAAK,SAAS,eAAe,KAAK,KAAK;AACpF,YAAI,KAAK,mBAAmB;AACxB,eAAK,kBAAkB,QAAQ;AAAA,QACnC;AAQA,iBAAS,SAAS,MAAM,QAAQ;AAChC,aAAK,UAAU,OAAM;AAAA,MACzB;AACA;AACA,WAAK,eAAc;AAAA,IACvB;AAAA,EACJ;AAAA,EACA,OAAO;AACH,QAAI,KAAK;AACL;AACJ,SAAK,kBAAkB;AACvB,SAAK,UAAU,KAAI;AACnB,QAAI,KAAK,UAAU,YAAY;AAC3B,WAAK,eAAc;AAAA,IACvB;AAAA,EACJ;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,MAAK;AAAA,EACxB;AAAA,EACA,WAAW;;AACP,qBAAK,WAAU,WAAf;AAAA,EACJ;AAAA,EACA,SAAS;AACL,QAAI;AACA,WAAK,UAAU,OAAM;AAAA,IACzB,SACO,GAAG;AAAA,IAAE;AAAA,EAChB;AAAA,EACA,OAAO;AACH,QAAI,KAAK;AACL;AACJ,SAAK,YAAY;AACjB,UAAM,EAAE,MAAK,IAAK;AAClB,QAAI,UAAU,UAAU,UAAU,YAAY;AAC1C;AAAA,IACJ;AACA,QAAI,KAAK,mBAAmB;AACxB,WAAK,kBAAiB;AAAA,IAC1B,OACK;AACD,WAAK,aAAY;AAAA,IACrB;AACA,QAAI,CAAC,KAAK;AACN,WAAK,OAAM;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,eAAe;;AACX,UAAM,WAAU,UAAK,YAAL,mBAAc;AAC9B,QAAI,CAAC,KAAK,oBAAmB,mCAAS,cAAa;AAC/C,uBAAK,WAAU,iBAAf;AAAA,IACJ;AAAA,EACJ;AAAA,EACA,IAAI,WAAW;;AACX,UAAM,aAAW,gBAAK,UAAU,WAAf,mBAAuB,sBAAvB,4BAA6C,aAAY;AAC1E,WAAO,sBAAsB,OAAO,QAAQ,CAAC;AAAA,EACjD;AAAA,EACA,IAAI,oBAAoB;AACpB,UAAM,EAAE,QAAQ,EAAC,IAAK,KAAK,WAAW,CAAA;AACtC,WAAO,KAAK,WAAW,sBAAsB,KAAK;AAAA,EACtD;AAAA,EACA,IAAI,OAAO;AACP,WAAO,sBAAsB,OAAO,KAAK,UAAU,WAAW,KAAK,CAAC;AAAA,EACxE;AAAA,EACA,IAAI,KAAK,SAAS;AACd,UAAM,cAAc,KAAK,iBAAiB;AAC1C,SAAK,kBAAkB;AACvB,SAAK,eAAe;AACpB,SAAK,UAAU,cAAc,sBAAsB,OAAO;AAC1D,QAAI,aAAa;AACb,WAAK,UAAU,MAAK;AAAA,IACxB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,QAAQ;AACR,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,IAAI,MAAM,UAAU;AAEhB,QAAI,WAAW;AACX,WAAK,eAAe;AACxB,SAAK,UAAU,eAAe;AAAA,EAClC;AAAA,EACA,IAAI,QAAQ;AACR,WAAO,KAAK,iBAAiB,OACvB,aACA,KAAK,UAAU;AAAA,EACzB;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,mBAAmB,OAAO,KAAK,UAAU,SAAS;AAAA,EAClE;AAAA,EACA,IAAI,UAAU,cAAc;AACxB,SAAK,kBAAkB,KAAK,UAAU,YAAY;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA,EAIA,eAAe,EAAE,UAAU,YAAY,UAAU,QAAO,GAAK;;AACzD,QAAI,KAAK,cAAc;AACnB,iBAAK,UAAU,WAAf,mBAAuB,aAAa,EAAE,QAAQ;IAClD;AACA,SAAK,UAAU,WAAW;AAC1B,QAAI,YAAY,0BAA0B;AACtC,WAAK,UAAU,WAAW;AAC1B,UAAI;AACA,aAAK,UAAU,aAAa;AAChC,UAAI;AACA,aAAK,UAAU,WAAW;AAC9B,aAAO;AAAA,IACX,OACK;AACD,aAAO,QAAQ,IAAI;AAAA,IACvB;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.js

@@ -1,52 +0,0 @@
-import { time } from "../frameloop/sync-time.js";
-import { setStyle } from "../render/dom/style-set.js";
-import { JSAnimation } from "./JSAnimation.js";
-import { NativeAnimation } from "./NativeAnimation.js";
-import { replaceTransitionType } from "./utils/replace-transition-type.js";
-import { replaceStringEasing } from "./waapi/utils/unsupported-easing.js";
-import { clamp } from "../../../../motion-utils/dist/es/clamp.js";
-const sampleDelta = 10;
-class NativeAnimationExtended extends NativeAnimation {
-  constructor(options) {
-    replaceStringEasing(options);
-    replaceTransitionType(options);
-    super(options);
-    if (options.startTime !== void 0 && options.autoplay !== false) {
-      this.startTime = options.startTime;
-    }
-    this.options = options;
-  }
-  /**
-   * WAAPI doesn't natively have any interruption capabilities.
-   *
-   * Rather than read committed 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 !== void 0) {
-      motionValue.set(value);
-      return;
-    }
-    const sampleAnimation = new JSAnimation({
-      ...options,
-      autoplay: false
-    });
-    const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);
-    const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);
-    const current = sampleAnimation.sample(sampleTime).value;
-    const { name } = this.options;
-    if (element && name)
-      setStyle(element, name, current);
-    motionValue.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);
-    sampleAnimation.stop();
-  }
-}
-export {
-  NativeAnimationExtended
-};
-//# sourceMappingURL=NativeAnimationExtended.js.map

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativeAnimationExtended.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs"],"sourcesContent":["import { clamp } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { setStyle } from '../render/dom/style-set.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { NativeAnimation } from './NativeAnimation.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { replaceStringEasing } from './waapi/utils/unsupported-easing.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\nclass NativeAnimationExtended extends NativeAnimation {\n    constructor(options) {\n        /**\n         * The base NativeAnimation function only supports a subset\n         * of Motion easings, and WAAPI also only supports some\n         * easing functions via string/cubic-bezier definitions.\n         *\n         * This function replaces those unsupported easing functions\n         * with a JS easing function. This will later get compiled\n         * to a linear() easing function.\n         */\n        replaceStringEasing(options);\n        /**\n         * Ensure we replace the transition type with a generator function\n         * before passing to WAAPI.\n         *\n         * TODO: Does this have a better home? It could be shared with\n         * JSAnimation.\n         */\n        replaceTransitionType(options);\n        super(options);\n        /**\n         * Only set startTime when the animation should autoplay.\n         * Setting startTime on a paused WAAPI animation unpauses it\n         * (per the WAAPI spec), which breaks autoplay: false.\n         */\n        if (options.startTime !== undefined && options.autoplay !== false) {\n            this.startTime = options.startTime;\n        }\n        this.options = options;\n    }\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * Rather than read committed styles back out of the DOM, we can\n     * create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to calculate velocity for any subsequent animation.\n     */\n    updateMotionValue(value) {\n        const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n        if (!motionValue)\n            return;\n        if (value !== undefined) {\n            motionValue.set(value);\n            return;\n        }\n        const sampleAnimation = new JSAnimation({\n            ...options,\n            autoplay: false,\n        });\n        /**\n         * Use wall-clock elapsed time for sampling.\n         * Under CPU load, WAAPI's currentTime may not reflect actual\n         * elapsed time, causing incorrect sampling and visual jumps.\n         */\n        const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);\n        const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);\n        const current = sampleAnimation.sample(sampleTime).value;\n        /**\n         * Write the estimated value to inline style so it persists\n         * after cancel(), covering the async gap before the next\n         * animation starts.\n         */\n        const { name } = this.options;\n        if (element && name)\n            setStyle(element, name, current);\n        motionValue.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);\n        sampleAnimation.stop();\n    }\n}\n\nexport { NativeAnimationExtended };\n//# sourceMappingURL=NativeAnimationExtended.mjs.map\n"],"names":[],"mappings":";;;;;;;AAaA,MAAM,cAAc;AACpB,MAAM,gCAAgC,gBAAgB;AAAA,EAClD,YAAY,SAAS;AAUjB,wBAAoB,OAAO;AAQ3B,0BAAsB,OAAO;AAC7B,UAAM,OAAO;AAMb,QAAI,QAAQ,cAAc,UAAa,QAAQ,aAAa,OAAO;AAC/D,WAAK,YAAY,QAAQ;AAAA,IAC7B;AACA,SAAK,UAAU;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,kBAAkB,OAAO;AACrB,UAAM,EAAE,aAAa,UAAU,YAAY,SAAS,GAAG,QAAO,IAAK,KAAK;AACxE,QAAI,CAAC;AACD;AACJ,QAAI,UAAU,QAAW;AACrB,kBAAY,IAAI,KAAK;AACrB;AAAA,IACJ;AACA,UAAM,kBAAkB,IAAI,YAAY;AAAA,MACpC,GAAG;AAAA,MACH,UAAU;AAAA,IACtB,CAAS;AAMD,UAAM,aAAa,KAAK,IAAI,aAAa,KAAK,IAAG,IAAK,KAAK,SAAS;AACpE,UAAM,QAAQ,MAAM,GAAG,aAAa,aAAa,WAAW;AAC5D,UAAM,UAAU,gBAAgB,OAAO,UAAU,EAAE;AAMnD,UAAM,EAAE,SAAS,KAAK;AACtB,QAAI,WAAW;AACX,eAAS,SAAS,MAAM,OAAO;AACnC,gBAAY,gBAAgB,gBAAgB,OAAO,KAAK,IAAI,GAAG,aAAa,KAAK,CAAC,EAAE,OAAO,SAAS,KAAK;AACzG,oBAAgB,KAAI;AAAA,EACxB;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/motion-dom/dist/es/animation/animate/single-value.js

@@ -1,12 +0,0 @@
-import { animateMotionValue } from "../interfaces/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
-};
-//# sourceMappingURL=single-value.js.map

package/dist/node_modules/motion-dom/dist/es/animation/animate/single-value.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"single-value.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/animate/single-value.mjs"],"sourcesContent":["import { animateMotionValue } from '../interfaces/motion-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction animateSingleValue(value, keyframes, options) {\n    const motionValue$1 = isMotionValue(value) ? value : motionValue(value);\n    motionValue$1.start(animateMotionValue(\"\", motionValue$1, keyframes, options));\n    return motionValue$1.animation;\n}\n\nexport { animateSingleValue };\n//# sourceMappingURL=single-value.mjs.map\n"],"names":[],"mappings":";;;AAIA,SAAS,mBAAmB,OAAO,WAAW,SAAS;AACnD,QAAM,gBAAgB,cAAc,KAAK,IAAI,QAAQ,YAAY,KAAK;AACtE,gBAAc,MAAM,mBAAmB,IAAI,eAAe,WAAW,OAAO,CAAC;AAC7E,SAAO,cAAc;AACzB;","x_google_ignoreList":[0]}

package/dist/node_modules/motion-dom/dist/es/animation/drivers/frame.js

@@ -1,18 +0,0 @@
-import { time } from "../../frameloop/sync-time.js";
-import { frameData, cancelFrame, frame } from "../../frameloop/frame.js";
-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
-};
-//# sourceMappingURL=frame.js.map

package/dist/node_modules/motion-dom/dist/es/animation/drivers/frame.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frame.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/drivers/frame.mjs"],"sourcesContent":["import { time } from '../../frameloop/sync-time.mjs';\nimport { frameData, cancelFrame, frame } from '../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: (keepAlive = true) => frame.update(passTimestamp, keepAlive),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n//# sourceMappingURL=frame.mjs.map\n"],"names":[],"mappings":";;AAGK,MAAC,kBAAkB,CAAC,WAAW;AAChC,QAAM,gBAAgB,CAAC,EAAE,UAAS,MAAO,OAAO,SAAS;AACzD,SAAO;AAAA,IACH,OAAO,CAAC,YAAY,SAAS,MAAM,OAAO,eAAe,SAAS;AAAA,IAClE,MAAM,MAAM,YAAY,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA,IAKrC,KAAK,MAAO,UAAU,eAAe,UAAU,YAAY,KAAK;EACxE;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/motion-dom/dist/es/animation/generators/inertia.js

@@ -1,68 +0,0 @@
-import { spring } from "./spring.js";
-import { getGeneratorVelocity } from "./utils/velocity.js";
-function inertia({ keyframes, velocity = 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 !== void 0 && v < min || max !== void 0 && v > max;
-  const nearestBoundary = (v) => {
-    if (min === void 0)
-      return max;
-    if (max === void 0)
-      return min;
-    return Math.abs(min - v) < Math.abs(max - v) ? min : max;
-  };
-  let amplitude = power * velocity;
-  const ideal = origin + amplitude;
-  const target = modifyTarget === void 0 ? ideal : modifyTarget(ideal);
-  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;
-  };
-  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: getGeneratorVelocity(calcLatest, t, state.value),
-      // TODO: This should be passing * 1000
-      damping: bounceDamping,
-      stiffness: bounceStiffness,
-      restDelta,
-      restSpeed
-    });
-  };
-  checkCatchBoundary(0);
-  return {
-    calculatedDuration: null,
-    next: (t) => {
-      let hasUpdatedFrame = false;
-      if (!spring$1 && timeReachedBoundary === void 0) {
-        hasUpdatedFrame = true;
-        applyFriction(t);
-        checkCatchBoundary(t);
-      }
-      if (timeReachedBoundary !== void 0 && t >= timeReachedBoundary) {
-        return spring$1.next(t - timeReachedBoundary);
-      } else {
-        !hasUpdatedFrame && applyFriction(t);
-        return state;
-      }
-    }
-  };
-}
-export {
-  inertia
-};
-//# sourceMappingURL=inertia.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/inertia.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inertia.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["import { spring } from './spring.mjs';\nimport { getGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: getGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n//# sourceMappingURL=inertia.mjs.map\n"],"names":[],"mappings":";;AAGA,SAAS,QAAQ,EAAE,WAAW,WAAW,GAAK,QAAQ,KAAK,eAAe,KAAK,gBAAgB,IAAI,kBAAkB,KAAK,cAAc,KAAK,KAAK,YAAY,KAAK,aAAc;AAC7K,QAAM,SAAS,UAAU,CAAC;AAC1B,QAAM,QAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAO;AAAA,EACf;AACI,QAAM,gBAAgB,CAAC,MAAO,QAAQ,UAAa,IAAI,OAAS,QAAQ,UAAa,IAAI;AACzF,QAAM,kBAAkB,CAAC,MAAM;AAC3B,QAAI,QAAQ;AACR,aAAO;AACX,QAAI,QAAQ;AACR,aAAO;AACX,WAAO,KAAK,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,MAAM;AAAA,EACzD;AACA,MAAI,YAAY,QAAQ;AACxB,QAAM,QAAQ,SAAS;AACvB,QAAM,SAAS,iBAAiB,SAAY,QAAQ,aAAa,KAAK;AAKtE,MAAI,WAAW;AACX,gBAAY,SAAS;AACzB,QAAM,YAAY,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,IAAI,YAAY;AAChE,QAAM,aAAa,CAAC,MAAM,SAAS,UAAU,CAAC;AAC9C,QAAM,gBAAgB,CAAC,MAAM;AACzB,UAAM,QAAQ,UAAU,CAAC;AACzB,UAAM,SAAS,WAAW,CAAC;AAC3B,UAAM,OAAO,KAAK,IAAI,KAAK,KAAK;AAChC,UAAM,QAAQ,MAAM,OAAO,SAAS;AAAA,EACxC;AAOA,MAAI;AACJ,MAAI;AACJ,QAAM,qBAAqB,CAAC,MAAM;AAC9B,QAAI,CAAC,cAAc,MAAM,KAAK;AAC1B;AACJ,0BAAsB;AACtB,eAAW,OAAO;AAAA,MACd,WAAW,CAAC,MAAM,OAAO,gBAAgB,MAAM,KAAK,CAAC;AAAA,MACrD,UAAU,qBAAqB,YAAY,GAAG,MAAM,KAAK;AAAA;AAAA,MACzD,SAAS;AAAA,MACT,WAAW;AAAA,MACX;AAAA,MACA;AAAA,IACZ,CAAS;AAAA,EACL;AACA,qBAAmB,CAAC;AACpB,SAAO;AAAA,IACH,oBAAoB;AAAA,IACpB,MAAM,CAAC,MAAM;AAOT,UAAI,kBAAkB;AACtB,UAAI,CAAC,YAAY,wBAAwB,QAAW;AAChD,0BAAkB;AAClB,sBAAc,CAAC;AACf,2BAAmB,CAAC;AAAA,MACxB;AAKA,UAAI,wBAAwB,UAAa,KAAK,qBAAqB;AAC/D,eAAO,SAAS,KAAK,IAAI,mBAAmB;AAAA,MAChD,OACK;AACD,SAAC,mBAAmB,cAAc,CAAC;AACnC,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

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

@@ -1,38 +0,0 @@
-import { interpolate } from "../../utils/interpolate.js";
-import { defaultOffset } from "../keyframes/offsets/default.js";
-import { convertOffsetToTimes } from "../keyframes/offsets/time.js";
-import { isEasingArray } from "../../../../../motion-utils/dist/es/easing/utils/is-easing-array.js";
-import { easingDefinitionToFunction } from "../../../../../motion-utils/dist/es/easing/utils/map.js";
-import { easeInOut } from "../../../../../motion-utils/dist/es/easing/ease.js";
-function defaultEasing(values, easing) {
-  return values.map(() => easing || easeInOut).splice(0, values.length - 1);
-}
-function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut" }) {
-  const easingFunctions = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);
-  const state = {
-    done: false,
-    value: keyframeValues[0]
-  };
-  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
-};
-//# sourceMappingURL=keyframes.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/keyframes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyframes.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs"],"sourcesContent":["import { easeInOut, isEasingArray, easingDefinitionToFunction } from 'motion-utils';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../keyframes/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../keyframes/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n//# sourceMappingURL=keyframes.mjs.map\n"],"names":[],"mappings":";;;;;;AAKA,SAAS,cAAc,QAAQ,QAAQ;AACnC,SAAO,OAAO,IAAI,MAAM,UAAU,SAAS,EAAE,OAAO,GAAG,OAAO,SAAS,CAAC;AAC5E;AACA,SAAS,UAAU,EAAE,WAAW,KAAK,WAAW,gBAAgB,OAAO,OAAO,eAAgB;AAK1F,QAAM,kBAAkB,cAAc,IAAI,IACpC,KAAK,IAAI,0BAA0B,IACnC,2BAA2B,IAAI;AAKrC,QAAM,QAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAO,eAAe,CAAC;AAAA,EAC/B;AAII,QAAM,gBAAgB;AAAA;AAAA;AAAA,IAGtB,SAAS,MAAM,WAAW,eAAe,SACnC,QACA,cAAc,cAAc;AAAA,IAAG;AAAA,EAAQ;AAC7C,QAAM,oBAAoB,YAAY,eAAe,gBAAgB;AAAA,IACjE,MAAM,MAAM,QAAQ,eAAe,IAC7B,kBACA,cAAc,gBAAgB,eAAe;AAAA,EAC3D,CAAK;AACD,SAAO;AAAA,IACH,oBAAoB;AAAA,IACpB,MAAM,CAAC,MAAM;AACT,YAAM,QAAQ,kBAAkB,CAAC;AACjC,YAAM,OAAO,KAAK;AAClB,aAAO;AAAA,IACX;AAAA,EACR;AACA;","x_google_ignoreList":[0]}