@ape.swap/bonds-sdk 5.1.0 → 5.1.1-test.0

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["import { spring } from './spring/index.mjs';\nimport { calcGeneratorVelocity } 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: calcGeneratorVelocity(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"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs"],"sourcesContent":["import { easeInOut } from '../../easing/ease.mjs';\nimport { isEasingArray } from '../../easing/utils/is-easing-array.mjs';\nimport { easingDefinitionToFunction } from '../../easing/utils/map.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/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"],"names":[],"mappings":";;;;;;;AAOA,SAAS,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE;AACvC,IAAI,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,MAAM,IAAI,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7E;AACA,SAAS,SAAS,CAAC,EAAE,QAAQ,GAAG,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,IAAI,GAAG,WAAW,GAAG,EAAE;AAC9F;AACA;AACA;AACA;AACA,IAAI,MAAM,eAAe,GAAG,aAAa,CAAC,IAAI;AAC9C,UAAU,IAAI,CAAC,GAAG,CAAC,0BAA0B;AAC7C,UAAU,0BAA0B,CAAC,IAAI,CAAC;AAC1C;AACA;AACA;AACA;AACA,IAAI,MAAM,KAAK,GAAG;AAClB,QAAQ,IAAI,EAAE,KAAK;AACnB,QAAQ,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC;AAChC,KAAK;AACL;AACA;AACA;AACA,IAAI,MAAM,aAAa,GAAG,oBAAoB;AAC9C;AACA;AACA,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,cAAc,CAAC;AAC7C,UAAU;AACV,UAAU,aAAa,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC;AAClD,IAAI,MAAM,iBAAiB,GAAG,WAAW,CAAC,aAAa,EAAE,cAAc,EAAE;AACzE,QAAQ,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,eAAe;AAC3C,cAAc;AACd,cAAc,aAAa,CAAC,cAAc,EAAE,eAAe,CAAC;AAC5D,KAAK,CAAC;AACN,IAAI,OAAO;AACX,QAAQ,kBAAkB,EAAE,QAAQ;AACpC,QAAQ,IAAI,EAAE,CAAC,CAAC,KAAK;AACrB,YAAY,KAAK,CAAC,KAAK,GAAG,iBAAiB,CAAC,CAAC,CAAC;AAC9C,YAAY,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,QAAQ;AACtC,YAAY,OAAO,KAAK;AACxB,QAAQ,CAAC;AACT,KAAK;AACL;;;;","x_google_ignoreList":[0]}

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

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

package/dist/node_modules/framer-motion/dist/es/animation/generators/spring/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/defaults.mjs"],"sourcesContent":["const springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\n\nexport { springDefaults };\n"],"names":[],"mappings":"AAAK,MAAC,cAAc,GAAG;AACvB;AACA,IAAI,SAAS,EAAE,GAAG;AAClB,IAAI,OAAO,EAAE,EAAE;AACf,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,QAAQ,EAAE,GAAG;AACjB;AACA,IAAI,QAAQ,EAAE,GAAG;AACjB,IAAI,MAAM,EAAE,GAAG;AACf,IAAI,cAAc,EAAE,GAAG;AACvB;AACA,IAAI,SAAS,EAAE;AACf,QAAQ,QAAQ,EAAE,IAAI;AACtB,QAAQ,OAAO,EAAE,CAAC;AAClB,KAAK;AACL,IAAI,SAAS,EAAE;AACf,QAAQ,QAAQ,EAAE,KAAK;AACvB,QAAQ,OAAO,EAAE,GAAG;AACpB,KAAK;AACL;AACA,IAAI,WAAW,EAAE,IAAI;AACrB,IAAI,WAAW,EAAE,IAAI;AACrB,IAAI,UAAU,EAAE,IAAI;AACpB,IAAI,UAAU,EAAE,CAAC;AACjB;;;;","x_google_ignoreList":[0]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"find.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs"],"sourcesContent":["import { warning, secondsToMilliseconds, millisecondsToSeconds } from 'motion-utils';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { springDefaults } from './defaults.mjs';\n\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring };\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { calcGeneratorDuration, maxGeneratorDuration, generateLinearEasing } from 'motion-dom';\nimport { millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { springDefaults } from './defaults.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring(options);\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\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 = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = 0.0;\n                /**\n                 * We only need to calculate velocity for under-damped springs\n                 * as over- and critically-damped springs can't overshoot, so\n                 * checking only for displacement is enough.\n                 */\n                if (dampingRatio < 1) {\n                    currentVelocity =\n                        t === 0\n                            ? secondsToMilliseconds(initialVelocity)\n                            : calcGeneratorVelocity(resolveSpring, t, current);\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n    };\n    return generator;\n}\n\nexport { spring };\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"velocity.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from '../../../utils/velocity-per-second.mjs';\n\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n"],"names":[],"mappings":";;AAEA,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACjC,SAAS,qBAAqB,CAAC,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE;AACzD,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,sBAAsB,EAAE,CAAC,CAAC;AACzD,IAAI,OAAO,iBAAiB,CAAC,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;AACtE;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/hooks/animation-controls.js

@@ -0,0 +1,81 @@
+import { invariant } from '../../../../../motion-utils/dist/es/errors.js';
+import { setTarget } from '../../render/utils/setters.js';
+import { animateVisualElement } from '../interfaces/visual-element.js';
+
+function stopAnimation(visualElement) {
+    visualElement.values.forEach((value) => value.stop());
+}
+function setVariants(visualElement, variantLabels) {
+    const reversedLabels = [...variantLabels].reverse();
+    reversedLabels.forEach((key) => {
+        const variant = visualElement.getVariant(key);
+        variant && setTarget(visualElement, variant);
+        if (visualElement.variantChildren) {
+            visualElement.variantChildren.forEach((child) => {
+                setVariants(child, variantLabels);
+            });
+        }
+    });
+}
+function setValues(visualElement, definition) {
+    if (Array.isArray(definition)) {
+        return setVariants(visualElement, definition);
+    }
+    else if (typeof definition === "string") {
+        return setVariants(visualElement, [definition]);
+    }
+    else {
+        setTarget(visualElement, definition);
+    }
+}
+/**
+ * @public
+ */
+function animationControls() {
+    /**
+     * Track whether the host component has mounted.
+     */
+    let hasMounted = false;
+    /**
+     * A collection of linked component animation controls.
+     */
+    const subscribers = new Set();
+    const controls = {
+        subscribe(visualElement) {
+            subscribers.add(visualElement);
+            return () => void subscribers.delete(visualElement);
+        },
+        start(definition, transitionOverride) {
+            invariant(hasMounted, "controls.start() should only be called after a component has mounted. Consider calling within a useEffect hook.");
+            const animations = [];
+            subscribers.forEach((visualElement) => {
+                animations.push(animateVisualElement(visualElement, definition, {
+                    transitionOverride,
+                }));
+            });
+            return Promise.all(animations);
+        },
+        set(definition) {
+            invariant(hasMounted, "controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.");
+            return subscribers.forEach((visualElement) => {
+                setValues(visualElement, definition);
+            });
+        },
+        stop() {
+            subscribers.forEach((visualElement) => {
+                stopAnimation(visualElement);
+            });
+        },
+        mount() {
+            hasMounted = true;
+            return () => {
+                hasMounted = false;
+                controls.stop();
+            };
+        },
+    };
+    return controls;
+}
+
+export { animationControls, setValues };
+//# sourceMappingURL=animation-controls.js.map

package/dist/node_modules/framer-motion/dist/es/animation/hooks/animation-controls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-controls.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/hooks/animation-controls.mjs"],"sourcesContent":["import { invariant } from 'motion-utils';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { animateVisualElement } from '../interfaces/visual-element.mjs';\n\nfunction stopAnimation(visualElement) {\n    visualElement.values.forEach((value) => value.stop());\n}\nfunction setVariants(visualElement, variantLabels) {\n    const reversedLabels = [...variantLabels].reverse();\n    reversedLabels.forEach((key) => {\n        const variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        if (visualElement.variantChildren) {\n            visualElement.variantChildren.forEach((child) => {\n                setVariants(child, variantLabels);\n            });\n        }\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\n/**\n * @public\n */\nfunction animationControls() {\n    /**\n     * Track whether the host component has mounted.\n     */\n    let hasMounted = false;\n    /**\n     * A collection of linked component animation controls.\n     */\n    const subscribers = new Set();\n    const controls = {\n        subscribe(visualElement) {\n            subscribers.add(visualElement);\n            return () => void subscribers.delete(visualElement);\n        },\n        start(definition, transitionOverride) {\n            invariant(hasMounted, \"controls.start() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            const animations = [];\n            subscribers.forEach((visualElement) => {\n                animations.push(animateVisualElement(visualElement, definition, {\n                    transitionOverride,\n                }));\n            });\n            return Promise.all(animations);\n        },\n        set(definition) {\n            invariant(hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            return subscribers.forEach((visualElement) => {\n                setValues(visualElement, definition);\n            });\n        },\n        stop() {\n            subscribers.forEach((visualElement) => {\n                stopAnimation(visualElement);\n            });\n        },\n        mount() {\n            hasMounted = true;\n            return () => {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\nexport { animationControls, setValues };\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}