@frontify/fondue 13.7.4 → 13.7.6

package/dist/node_modules/.pnpm/motion-dom@12.43.0/node_modules/motion-dom/dist/es/animation/JSAnimation.es.js

@@ -0,0 +1,150 @@
+import { time as u } from "../frameloop/sync-time.es.js";
+import { mix as P } from "../utils/mix/index.es.js";
+import { frameloopDriver as I } from "./drivers/frame.es.js";
+import { inertia as K } from "./generators/inertia.es.js";
+import { keyframes as c } from "./generators/keyframes.es.js";
+import { calcGeneratorDuration as O } from "./generators/utils/calc-duration.es.js";
+import { getGeneratorVelocity as V } from "./generators/utils/velocity.es.js";
+import { getFinalKeyframe as C } from "./keyframes/get-final.es.js";
+import { replaceTransitionType as E } from "./utils/replace-transition-type.es.js";
+import { WithPromise as N } from "./utils/WithPromise.es.js";
+import { invariant as W } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.es.js";
+import { pipe as $ } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/pipe.es.js";
+import { millisecondsToSeconds as f, secondsToMilliseconds as B } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.es.js";
+import { clamp as J } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.es.js";
+const U = (g) => g / 100;
+class rt extends N {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+      done: !1,
+      value: void 0
+    }, this.stop = () => {
+      var s, e;
+      const { motionValue: i } = this.options;
+      i && i.updatedAt !== u.now() && this.tick(u.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), (e = (s = this.options).onStop) == null || e.call(s));
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: t } = this;
+    E(t);
+    const { type: i = c, repeat: s = 0, repeatDelay: e = 0, repeatType: n, velocity: m = 0 } = t;
+    let { keyframes: r } = t;
+    const l = i || c;
+    process.env.NODE_ENV !== "production" && l !== c && W(r.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${r}`, "spring-two-frames"), l !== c && typeof r[0] != "number" && (this.mixKeyframes = $(U, P(r[0], r[1])), r = [0, 100]);
+    const o = l({ ...t, keyframes: r });
+    n === "mirror" && (this.mirroredGenerator = l({
+      ...t,
+      keyframes: [...r].reverse(),
+      velocity: -m
+    })), o.calculatedDuration === null && (o.calculatedDuration = O(o));
+    const { calculatedDuration: d } = o;
+    this.calculatedDuration = d, this.resolvedDuration = d + e, this.totalDuration = this.resolvedDuration * (s + 1) - e, this.generator = o;
+  }
+  updateTime(t) {
+    const i = Math.round(t - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = i;
+  }
+  tick(t, i = !1) {
+    const { generator: s, totalDuration: e, mixKeyframes: n, mirroredGenerator: m, resolvedDuration: r, calculatedDuration: l } = this;
+    if (this.startTime === null)
+      return s.next(0);
+    const { delay: o = 0, keyframes: d, repeat: k, repeatType: D, repeatDelay: S, type: F, onUpdate: b, finalKeyframe: G } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - e / this.speed, this.startTime)), i ? this.currentTime = t : this.updateTime(t);
+    const T = this.currentTime - o * (this.playbackSpeed >= 0 ? 1 : -1), y = this.playbackSpeed >= 0 ? T < 0 : T > e;
+    this.currentTime = Math.max(T, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = e);
+    let x = this.currentTime, w = s;
+    if (k) {
+      const v = Math.min(this.currentTime, e) / r;
+      let p = Math.floor(v), h = v % 1;
+      !h && v >= 1 && (h = 1), h === 1 && p--, p = Math.min(p, k + 1), !!(p % 2) && (D === "reverse" ? (h = 1 - h, S && (h -= S / r)) : D === "mirror" && (w = m)), x = J(0, 1, h) * r;
+    }
+    let a;
+    y ? (this.delayState.value = d[0], a = this.delayState) : a = w.next(x), n && !y && (a.value = n(a.value));
+    let { done: M } = a;
+    !y && l !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= e : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
+    return A && F !== K && (a.value = C(d, this.options, G, this.speed)), b && b(a.value), A && this.finish(), a;
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(t, i) {
+    return this.finished.then(t, i);
+  }
+  get duration() {
+    return f(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + f(t);
+  }
+  get time() {
+    return f(this.currentTime);
+  }
+  set time(t) {
+    t = B(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = t, this.tick(t));
+  }
+  /**
+   * Returns the generator's velocity at the current time in units/second.
+   * Uses the analytical derivative when available (springs), avoiding
+   * the MotionValue's frame-dependent velocity estimation.
+   */
+  getGeneratorVelocity() {
+    const t = this.currentTime;
+    if (t <= 0)
+      return this.options.velocity || 0;
+    if (this.generator.velocity)
+      return this.generator.velocity(t);
+    const i = this.generator.next(t).value;
+    return V((s) => this.generator.next(s).value, t, i);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const i = this.playbackSpeed !== t;
+    i && this.driver && this.updateTime(u.now()), this.playbackSpeed = t, i && this.driver && (this.time = f(this.currentTime));
+  }
+  play() {
+    var e, n;
+    if (this.isStopped)
+      return;
+    const { driver: t = I, startTime: i } = this.options;
+    this.driver || (this.driver = t((m) => this.tick(m))), (n = (e = this.options).onPlay) == null || n.call(e);
+    const s = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = i ?? s), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(u.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    var t, i;
+    this.notifyFinished(), this.teardown(), this.state = "finished", (i = (t = this.options).onComplete) == null || i.call(t);
+  }
+  cancel() {
+    var t, i;
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), (i = (t = this.options).onCancel) == null || i.call(t);
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+  attachTimeline(t) {
+    var i;
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), (i = this.driver) == null || i.stop(), t.observe(this);
+  }
+}
+export {
+  rt as JSAnimation
+};
+//# sourceMappingURL=JSAnimation.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JSAnimation.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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 { 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        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    }\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":["percentToProgress","percent","JSAnimation","WithPromise","options","motionValue","time","_b","_a","replaceTransitionType","type","keyframes","repeat","repeatDelay","repeatType","velocity","keyframes$1","generatorFactory","invariant","pipe","mix","generator","calcGeneratorDuration","calculatedDuration","timestamp","animationTime","sample","totalDuration","mixKeyframes","mirroredGenerator","resolvedDuration","delay","onUpdate","finalKeyframe","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","clamp","state","done","isAnimationFinished","inertia","getFinalKeyframe","resolve","reject","millisecondsToSeconds","newTime","secondsToMilliseconds","current","getGeneratorVelocity","newSpeed","hasChanged","driver","frameloopDriver","startTime","now","sampleTime","timeline"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,111 @@
+import { setStyle as u } from "../render/dom/style-set.es.js";
+import { supportsScrollTimeline as p } from "../utils/supports/scroll-timeline.es.js";
+import { getFinalKeyframe as f } from "./keyframes/get-final.es.js";
+import { WithPromise as d } from "./utils/WithPromise.es.js";
+import { startWaapiAnimation as c } from "./waapi/start-waapi-animation.es.js";
+import { applyGeneratorOptions as T } from "./waapi/utils/apply-generator.es.js";
+import { invariant as y } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.es.js";
+import { millisecondsToSeconds as o, secondsToMilliseconds as S } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.es.js";
+import { noop as g } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/noop.es.js";
+class x extends d {
+  constructor(i) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !i)
+      return;
+    const { element: t, name: e, keyframes: n, pseudoElement: s, allowFlatten: h = !1, finalKeyframe: l, onComplete: a } = i;
+    this.isPseudoElement = !!s, this.allowFlatten = h, this.options = i, y(typeof i.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
+    const m = T(i);
+    this.animation = c(t, e, n, m, s), m.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !s) {
+        const r = f(n, this.options, l, this.speed);
+        this.updateMotionValue && this.updateMotionValue(r), u(t, e, r), this.animation.cancel();
+      }
+      a == null || a(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    var i, t;
+    (t = (i = this.animation).finish) == null || t.call(i);
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: i } = this;
+    i === "idle" || i === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), 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 t, e, n;
+    const i = (t = this.options) == null ? void 0 : t.element;
+    !this.isPseudoElement && (i != null && i.isConnected) && ((n = (e = this.animation).commitStyles) == null || n.call(e));
+  }
+  get duration() {
+    var t, e;
+    const i = ((e = (t = this.animation.effect) == null ? void 0 : t.getComputedTiming) == null ? void 0 : e.call(t).duration) || 0;
+    return o(Number(i));
+  }
+  get iterationDuration() {
+    const { delay: i = 0 } = this.options || {};
+    return this.duration + o(i);
+  }
+  get time() {
+    return o(Number(this.animation.currentTime) || 0);
+  }
+  set time(i) {
+    const t = this.finishedTime !== null;
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = S(i), t && 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(i) {
+    i < 0 && (this.finishedTime = null), this.animation.playbackRate = i;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(i) {
+    this.manualStartTime = this.animation.startTime = i;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: i, rangeStart: t, rangeEnd: e, observe: n }) {
+    var s;
+    return this.allowFlatten && ((s = this.animation.effect) == null || s.updateTiming({ easing: "linear" })), this.animation.onfinish = null, i && p() ? (this.animation.timeline = i, t && (this.animation.rangeStart = t), e && (this.animation.rangeEnd = e), g) : n(this);
+  }
+}
+export {
+  x as NativeAnimation
+};
+//# sourceMappingURL=NativeAnimation.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimation.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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":["NativeAnimation","WithPromise","options","element","name","keyframes","pseudoElement","allowFlatten","finalKeyframe","onComplete","invariant","transition","applyGeneratorOptions","startWaapiAnimation","keyframe","getFinalKeyframe","setStyle","_b","_a","state","_c","duration","millisecondsToSeconds","delay","newTime","wasFinished","secondsToMilliseconds","newSpeed","newStartTime","timeline","rangeStart","rangeEnd","observe","supportsScrollTimeline","noop"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,39 @@
+import { time as p } from "../frameloop/sync-time.es.js";
+import { setStyle as c } from "../render/dom/style-set.es.js";
+import { JSAnimation as f } from "./JSAnimation.es.js";
+import { NativeAnimation as u } from "./NativeAnimation.es.js";
+import { replaceTransitionType as d } from "./utils/replace-transition-type.es.js";
+import { replaceStringEasing as h } from "./waapi/utils/unsupported-easing.es.js";
+import { clamp as T } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.es.js";
+const o = 10;
+class N extends u {
+  constructor(t) {
+    h(t), d(t), super(t), t.startTime !== void 0 && t.autoplay !== !1 && (this.startTime = t.startTime), this.options = t;
+  }
+  /**
+   * 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(t) {
+    const { motionValue: e, onUpdate: y, onComplete: A, element: m, ...l } = this.options;
+    if (!e)
+      return;
+    if (t !== void 0) {
+      e.set(t);
+      return;
+    }
+    const i = new f({
+      ...l,
+      autoplay: !1
+    }), a = Math.max(o, p.now() - this.startTime), n = T(0, o, a - o), r = i.sample(a).value, { name: s } = this.options;
+    m && s && c(m, s, r), e.setWithVelocity(i.sample(Math.max(0, a - n)).value, r, n), i.stop();
+  }
+}
+export {
+  N as NativeAnimationExtended
+};
+//# sourceMappingURL=NativeAnimationExtended.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimationExtended.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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":["sampleDelta","NativeAnimationExtended","NativeAnimation","options","replaceStringEasing","replaceTransitionType","value","motionValue","onUpdate","onComplete","element","sampleAnimation","JSAnimation","sampleTime","time","delta","clamp","current","name","setStyle"],"mappings":";;;;;;;AAaA,MAAMA,IAAc;AACpB,MAAMC,UAAgCC,EAAgB;AAAA,EAClD,YAAYC,GAAS;AAUjB,IAAAC,EAAoBD,CAAO,GAQ3BE,EAAsBF,CAAO,GAC7B,MAAMA,CAAO,GAMTA,EAAQ,cAAc,UAAaA,EAAQ,aAAa,OACxD,KAAK,YAAYA,EAAQ,YAE7B,KAAK,UAAUA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,kBAAkBG,GAAO;AACrB,UAAM,EAAE,aAAAC,GAAa,UAAAC,GAAU,YAAAC,GAAY,SAAAC,GAAS,GAAGP,EAAO,IAAK,KAAK;AACxE,QAAI,CAACI;AACD;AACJ,QAAID,MAAU,QAAW;AACrB,MAAAC,EAAY,IAAID,CAAK;AACrB;AAAA,IACJ;AACA,UAAMK,IAAkB,IAAIC,EAAY;AAAA,MACpC,GAAGT;AAAA,MACH,UAAU;AAAA,IACtB,CAAS,GAMKU,IAAa,KAAK,IAAIb,GAAac,EAAK,IAAG,IAAK,KAAK,SAAS,GAC9DC,IAAQC,EAAM,GAAGhB,GAAaa,IAAab,CAAW,GACtDiB,IAAUN,EAAgB,OAAOE,CAAU,EAAE,OAM7C,EAAE,MAAAK,MAAS,KAAK;AACtB,IAAIR,KAAWQ,KACXC,EAAST,GAASQ,GAAMD,CAAO,GACnCV,EAAY,gBAAgBI,EAAgB,OAAO,KAAK,IAAI,GAAGE,IAAaE,CAAK,CAAC,EAAE,OAAOE,GAASF,CAAK,GACzGJ,EAAgB,KAAI;AAAA,EACxB;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"single-value.es.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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":["animateSingleValue","value","keyframes","options","motionValue$1","isMotionValue","motionValue","animateMotionValue"],"mappings":";;;AAIA,SAASA,EAAmBC,GAAOC,GAAWC,GAAS;AACnD,QAAMC,IAAgBC,EAAcJ,CAAK,IAAIA,IAAQK,EAAYL,CAAK;AACtE,SAAAG,EAAc,MAAMG,EAAmB,IAAIH,GAAeF,GAAWC,CAAO,CAAC,GACtEC,EAAc;AACzB;","x_google_ignoreList":[0]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.es.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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":["frameloopDriver","update","passTimestamp","timestamp","keepAlive","frame","cancelFrame","frameData","time"],"mappings":";;AAGK,MAACA,IAAkB,CAACC,MAAW;AAChC,QAAMC,IAAgB,CAAC,EAAE,WAAAC,EAAS,MAAOF,EAAOE,CAAS;AACzD,SAAO;AAAA,IACH,OAAO,CAACC,IAAY,OAASC,EAAM,OAAOH,GAAeE,CAAS;AAAA,IAClE,MAAM,MAAME,EAAYJ,CAAa;AAAA;AAAA;AAAA;AAAA;AAAA,IAKrC,KAAK,MAAOK,EAAU,eAAeA,EAAU,YAAYC,EAAK;EACxE;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.es.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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":["inertia","keyframes","velocity","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","min","max","restDelta","restSpeed","origin","state","isOutOfBounds","v","nearestBoundary","amplitude","ideal","target","calcDelta","t","calcLatest","applyFriction","delta","latest","timeReachedBoundary","spring$1","checkCatchBoundary","spring","getGeneratorVelocity","hasUpdatedFrame"],"mappings":";;AAGA,SAASA,EAAQ,EAAE,WAAAC,GAAW,UAAAC,IAAW,GAAK,OAAAC,IAAQ,KAAK,cAAAC,IAAe,KAAK,eAAAC,IAAgB,IAAI,iBAAAC,IAAkB,KAAK,cAAAC,GAAc,KAAAC,GAAK,KAAAC,GAAK,WAAAC,IAAY,KAAK,WAAAC,KAAc;AAC7K,QAAMC,IAASX,EAAU,CAAC,GACpBY,IAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAOD;AAAA,EACf,GACUE,IAAgB,CAACC,MAAOP,MAAQ,UAAaO,IAAIP,KAASC,MAAQ,UAAaM,IAAIN,GACnFO,IAAkB,CAACD,MACjBP,MAAQ,SACDC,IACPA,MAAQ,UAEL,KAAK,IAAID,IAAMO,CAAC,IAAI,KAAK,IAAIN,IAAMM,CAAC,IADhCP,IAC0CC;AAEzD,MAAIQ,IAAYd,IAAQD;AACxB,QAAMgB,IAAQN,IAASK,GACjBE,IAASZ,MAAiB,SAAYW,IAAQX,EAAaW,CAAK;AAKtE,EAAIC,MAAWD,MACXD,IAAYE,IAASP;AACzB,QAAMQ,IAAY,CAACC,MAAM,CAACJ,IAAY,KAAK,IAAI,CAACI,IAAIjB,CAAY,GAC1DkB,IAAa,CAACD,MAAMF,IAASC,EAAUC,CAAC,GACxCE,IAAgB,CAACF,MAAM;AACzB,UAAMG,IAAQJ,EAAUC,CAAC,GACnBI,IAASH,EAAWD,CAAC;AAC3B,IAAAR,EAAM,OAAO,KAAK,IAAIW,CAAK,KAAKd,GAChCG,EAAM,QAAQA,EAAM,OAAOM,IAASM;AAAA,EACxC;AAOA,MAAIC,GACAC;AACJ,QAAMC,IAAqB,CAACP,MAAM;AAC9B,IAAKP,EAAcD,EAAM,KAAK,MAE9Ba,IAAsBL,GACtBM,IAAWE,EAAO;AAAA,MACd,WAAW,CAAChB,EAAM,OAAOG,EAAgBH,EAAM,KAAK,CAAC;AAAA,MACrD,UAAUiB,EAAqBR,GAAYD,GAAGR,EAAM,KAAK;AAAA;AAAA,MACzD,SAASR;AAAA,MACT,WAAWC;AAAA,MACX,WAAAI;AAAA,MACA,WAAAC;AAAA,IACZ,CAAS;AAAA,EACL;AACA,SAAAiB,EAAmB,CAAC,GACb;AAAA,IACH,oBAAoB;AAAA,IACpB,MAAM,CAACP,MAAM;AAOT,UAAIU,IAAkB;AAUtB,aATI,CAACJ,KAAYD,MAAwB,WACrCK,IAAkB,IAClBR,EAAcF,CAAC,GACfO,EAAmBP,CAAC,IAMpBK,MAAwB,UAAaL,KAAKK,IACnCC,EAAS,KAAKN,IAAIK,CAAmB,KAG5C,CAACK,KAAmBR,EAAcF,CAAC,GAC5BR;AAAA,IAEf;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,31 @@
+import { interpolate as c } from "../../utils/interpolate.es.js";
+import { defaultOffset as p } from "../keyframes/offsets/default.es.js";
+import { convertOffsetToTimes as u } from "../keyframes/offsets/time.es.js";
+import { isEasingArray as l } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.es.js";
+import { easingDefinitionToFunction as m } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/map.es.js";
+import { easeInOut as g } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/ease.es.js";
+function T(n, t) {
+  return n.map(() => t || g).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = l(r) ? r.map(m) : m(r), i = {
+    done: !1,
+    value: t[0]
+  }, s = u(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    o && o.length === t.length ? o : p(t),
+    n
+  ), a = c(s, t, {
+    ease: Array.isArray(e) ? e : T(t, e)
+  });
+  return {
+    calculatedDuration: n,
+    next: (f) => (i.value = a(f), i.done = f >= n, i)
+  };
+}
+export {
+  T as defaultEasing,
+  y as keyframes
+};
+//# sourceMappingURL=keyframes.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.es.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.43.0/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":["defaultEasing","values","easing","easeInOut","keyframes","duration","keyframeValues","times","ease","easingFunctions","isEasingArray","easingDefinitionToFunction","state","absoluteTimes","convertOffsetToTimes","defaultOffset","mapTimeToKeyframe","interpolate","t"],"mappings":";;;;;;AAKA,SAASA,EAAcC,GAAQC,GAAQ;AACnC,SAAOD,EAAO,IAAI,MAAMC,KAAUC,CAAS,EAAE,OAAO,GAAGF,EAAO,SAAS,CAAC;AAC5E;AACA,SAASG,EAAU,EAAE,UAAAC,IAAW,KAAK,WAAWC,GAAgB,OAAAC,GAAO,MAAAC,IAAO,eAAgB;AAK1F,QAAMC,IAAkBC,EAAcF,CAAI,IACpCA,EAAK,IAAIG,CAA0B,IACnCA,EAA2BH,CAAI,GAK/BI,IAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAON,EAAe,CAAC;AAAA,EAC/B,GAIUO,IAAgBC;AAAA;AAAA;AAAA,IAGtBP,KAASA,EAAM,WAAWD,EAAe,SACnCC,IACAQ,EAAcT,CAAc;AAAA,IAAGD;AAAA,EAAQ,GACvCW,IAAoBC,EAAYJ,GAAeP,GAAgB;AAAA,IACjE,MAAM,MAAM,QAAQG,CAAe,IAC7BA,IACAT,EAAcM,GAAgBG,CAAe;AAAA,EAC3D,CAAK;AACD,SAAO;AAAA,IACH,oBAAoBJ;AAAA,IACpB,MAAM,CAACa,OACHN,EAAM,QAAQI,EAAkBE,CAAC,GACjCN,EAAM,OAAOM,KAAKb,GACXO;AAAA,EAEnB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/motion-dom@12.43.0/node_modules/motion-dom/dist/es/animation/generators/spring.es.js

@@ -0,0 +1,179 @@
+import { generateLinearEasing as L } from "../waapi/utils/linear.es.js";
+import { calcGeneratorDuration as z, maxGeneratorDuration as B } from "./utils/calc-duration.es.js";
+import { createGeneratorEasing as H } from "./utils/create-generator-easing.es.js";
+import { millisecondsToSeconds as K, secondsToMilliseconds as q } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.es.js";
+import { clamp as N } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.es.js";
+import { warning as J } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.es.js";
+const n = {
+  // Default spring physics
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 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: 5e-3,
+    default: 0.5
+  },
+  // Limits
+  minDuration: 0.01,
+  // in seconds
+  maxDuration: 10,
+  // in seconds
+  minDamping: 0.05,
+  maxDamping: 1
+};
+function O(e, s) {
+  return e * Math.sqrt(1 - s * s);
+}
+const Q = 12;
+function U(e, s, a) {
+  let l = a;
+  for (let f = 1; f < Q; f++)
+    l = l - e(l) / s(l);
+  return l;
+}
+const I = 1e-3;
+function W({ duration: e = n.duration, bounce: s = n.bounce, velocity: a = n.velocity, mass: l = n.mass }) {
+  let f, v;
+  J(e <= q(n.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let r = 1 - s;
+  r = N(n.minDamping, n.maxDamping, r), e = N(n.minDuration, n.maxDuration, K(e)), r < 1 ? (f = (c) => {
+    const g = c * r, h = g * e, k = g - a, x = O(c, r), M = Math.exp(-h);
+    return I - k / x * M;
+  }, v = (c) => {
+    const h = c * r * e, k = h * a + a, x = Math.pow(r, 2) * Math.pow(c, 2) * e, M = Math.exp(-h), o = O(Math.pow(c, 2), r);
+    return (-f(c) + I > 0 ? -1 : 1) * ((k - x) * M) / o;
+  }) : (f = (c) => {
+    const g = Math.exp(-c * e), h = (c - a) * e + 1;
+    return -I + g * h;
+  }, v = (c) => {
+    const g = Math.exp(-c * e), h = (a - c) * (e * e);
+    return g * h;
+  });
+  const p = 5 / e, T = U(f, v, p);
+  if (e = q(e), isNaN(T))
+    return {
+      stiffness: n.stiffness,
+      damping: n.damping,
+      duration: e
+    };
+  {
+    const c = Math.pow(T, 2) * l;
+    return {
+      stiffness: c,
+      damping: r * 2 * Math.sqrt(l * c),
+      duration: e
+    };
+  }
+}
+const X = ["duration", "bounce"], Y = ["stiffness", "damping", "mass"];
+function V(e, s) {
+  return s.some((a) => e[a] !== void 0);
+}
+function Z(e) {
+  let s = {
+    velocity: n.velocity,
+    stiffness: n.stiffness,
+    damping: n.damping,
+    mass: n.mass,
+    isResolvedFromDuration: !1,
+    ...e
+  };
+  if (!V(e, Y) && V(e, X))
+    if (s.velocity = 0, e.visualDuration) {
+      const a = e.visualDuration, l = 2 * Math.PI / (a * 1.2), f = l * l, v = 2 * N(0.05, 1, 1 - (e.bounce || 0)) * Math.sqrt(f);
+      s = {
+        ...s,
+        mass: n.mass,
+        stiffness: f,
+        damping: v
+      };
+    } else {
+      const a = W({ ...e, velocity: 0 });
+      s = {
+        ...s,
+        ...a,
+        mass: n.mass
+      }, s.isResolvedFromDuration = !0;
+    }
+  return s;
+}
+function j(e = n.visualDuration, s = n.bounce) {
+  const a = typeof e != "object" ? {
+    visualDuration: e,
+    keyframes: [0, 1],
+    bounce: s
+  } : e;
+  let { restSpeed: l, restDelta: f } = a;
+  const v = a.keyframes[0], r = a.keyframes[a.keyframes.length - 1], p = { done: !1, value: v }, { stiffness: T, damping: c, mass: g, duration: h, velocity: k, isResolvedFromDuration: x } = Z({
+    ...a,
+    velocity: -K(a.velocity || 0)
+  }), M = k || 0, o = c / (2 * Math.sqrt(T * g)), m = r - v, i = K(Math.sqrt(T / g)), P = Math.abs(m) < 5;
+  l || (l = P ? n.restSpeed.granular : n.restSpeed.default), f || (f = P ? n.restDelta.granular : n.restDelta.default);
+  let G, w, d, C, A, F;
+  if (o < 1)
+    d = O(i, o), C = (M + o * i * m) / d, G = (t) => {
+      const u = Math.exp(-o * i * t);
+      return r - u * (C * Math.sin(d * t) + m * Math.cos(d * t));
+    }, A = o * i * C + m * d, F = o * i * m - C * d, w = (t) => Math.exp(-o * i * t) * (A * Math.sin(d * t) + F * Math.cos(d * t));
+  else if (o === 1) {
+    G = (u) => r - Math.exp(-i * u) * (m + (M + i * m) * u);
+    const t = M + i * m;
+    w = (u) => Math.exp(-i * u) * (i * t * u - M);
+  } else {
+    const t = i * Math.sqrt(o * o - 1);
+    G = (y) => {
+      const S = Math.exp(-o * i * y), b = Math.min(t * y, 300);
+      return r - S * ((M + o * i * m) * Math.sinh(b) + t * m * Math.cosh(b)) / t;
+    };
+    const u = (M + o * i * m) / t, D = o * i * u - m * t, R = o * i * m - u * t;
+    w = (y) => {
+      const S = Math.exp(-o * i * y), b = Math.min(t * y, 300);
+      return S * (D * Math.sinh(b) + R * Math.cosh(b));
+    };
+  }
+  const E = {
+    calculatedDuration: x && h || null,
+    velocity: (t) => q(w(t)),
+    next: (t) => {
+      if (!x && o < 1) {
+        const D = Math.exp(-o * i * t), R = Math.sin(d * t), y = Math.cos(d * t), S = r - D * (C * R + m * y), b = q(D * (A * R + F * y));
+        return p.done = Math.abs(b) <= l && Math.abs(r - S) <= f, p.value = p.done ? r : S, p;
+      }
+      const u = G(t);
+      if (x)
+        p.done = t >= h;
+      else {
+        const D = q(w(t));
+        p.done = Math.abs(D) <= l && Math.abs(r - u) <= f;
+      }
+      return p.value = p.done ? r : u, p;
+    },
+    toString: () => {
+      const t = Math.min(z(E), B), u = L((D) => E.next(t * D).value, t, 30);
+      return t + "ms " + u;
+    },
+    toTransition: () => {
+    }
+  };
+  return E;
+}
+j.applyToOptions = (e) => {
+  const s = H(e, 100, j);
+  return e.ease = s.ease, e.duration = q(s.duration), e.type = "keyframes", e;
+};
+export {
+  j as spring
+};
+//# sourceMappingURL=spring.es.js.map