@new-black/lyra 0.1.8 → 0.1.9

package/dist/lyra213.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra213.cjs","sources":["../node_modules/framer-motion/dist/es/animation/animators/js/index.mjs"],"sourcesContent":["import { keyframes } from '../../generators/keyframes.mjs';\nimport { spring } from '../../generators/spring/index.mjs';\nimport { inertia } from '../../generators/inertia.mjs';\nimport { frameloopDriver } from './driver-frameloop.mjs';\nimport { interpolate } from '../../../utils/interpolate.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorDuration } from '../../generators/utils/calc-duration.mjs';\n\nconst types = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\n/**\n * Animate a single value on the main thread.\n *\n * This function is written, where functionality overlaps,\n * to be largely spec-compliant with WAAPI to allow fungibility\n * between the two.\n */\nfunction animateValue({ autoplay = true, delay = 0, driver = frameloopDriver, keyframes: keyframes$1, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", onPlay, onStop, onComplete, onUpdate, ...options }) {\n    let speed = 1;\n    let hasStopped = false;\n    let resolveFinishedPromise;\n    let currentFinishedPromise;\n    /**\n     * Resolve the current Promise every time we enter the\n     * finished state. This is WAAPI-compatible behaviour.\n     */\n    const updateFinishedPromise = () => {\n        currentFinishedPromise = new Promise((resolve) => {\n            resolveFinishedPromise = resolve;\n        });\n    };\n    // Create the first finished promise\n    updateFinishedPromise();\n    let animationDriver;\n    const generatorFactory = types[type] || keyframes;\n    /**\n     * If this isn't the keyframes generator and we've been provided\n     * strings as keyframes, we need to interpolate these.\n     * TODO: Support velocity for units and complex value types/\n     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        mapNumbersToKeyframes = interpolate([0, 100], keyframes$1, {\n            clamp: false,\n        });\n        keyframes$1 = [0, 100];\n    }\n    const generator = generatorFactory({ ...options, keyframes: keyframes$1 });\n    let mirroredGenerator;\n    if (repeatType === \"mirror\") {\n        mirroredGenerator = generatorFactory({\n            ...options,\n            keyframes: [...keyframes$1].reverse(),\n            velocity: -(options.velocity || 0),\n        });\n    }\n    let playState = \"idle\";\n    let holdTime = null;\n    let startTime = null;\n    let cancelTime = null;\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 && repeat) {\n        generator.calculatedDuration = calcGeneratorDuration(generator);\n    }\n    const { calculatedDuration } = generator;\n    let resolvedDuration = Infinity;\n    let totalDuration = Infinity;\n    if (calculatedDuration !== null) {\n        resolvedDuration = calculatedDuration + repeatDelay;\n        totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n    }\n    let currentTime = 0;\n    const tick = (timestamp) => {\n        if (startTime === null)\n            return;\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 (speed > 0)\n            startTime = Math.min(startTime, timestamp);\n        if (speed < 0)\n            startTime = Math.min(timestamp - totalDuration / speed, startTime);\n        if (holdTime !== null) {\n            currentTime = 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            currentTime = Math.round(timestamp - startTime) * speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = currentTime - delay * (speed >= 0 ? 1 : -1);\n        const isInDelayPhase = speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;\n        currentTime = Math.max(timeWithoutDelay, 0);\n        /**\n         * If this animation has finished, set the current time\n         * to the total duration.\n         */\n        if (playState === \"finished\" && holdTime === null) {\n            currentTime = totalDuration;\n        }\n        let elapsed = 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 = currentTime / 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 iterationIsOdd = Boolean(currentIteration % 2);\n            if (iterationIsOdd) {\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            let p = clamp(0, 1, iterationProgress);\n            if (currentTime > totalDuration) {\n                p = repeatType === \"reverse\" && iterationIsOdd ? 1 : 0;\n            }\n            elapsed = p * 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        const state = isInDelayPhase\n            ? { done: false, value: keyframes$1[0] }\n            : frameGenerator.next(elapsed);\n        if (mapNumbersToKeyframes) {\n            state.value = mapNumbersToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done = speed >= 0 ? currentTime >= totalDuration : currentTime <= 0;\n        }\n        const isAnimationFinished = holdTime === null &&\n            (playState === \"finished\" || (playState === \"running\" && done));\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            finish();\n        }\n        return state;\n    };\n    const stopAnimationDriver = () => {\n        animationDriver && animationDriver.stop();\n        animationDriver = undefined;\n    };\n    const cancel = () => {\n        playState = \"idle\";\n        stopAnimationDriver();\n        resolveFinishedPromise();\n        updateFinishedPromise();\n        startTime = cancelTime = null;\n    };\n    const finish = () => {\n        playState = \"finished\";\n        onComplete && onComplete();\n        stopAnimationDriver();\n        resolveFinishedPromise();\n    };\n    const play = () => {\n        if (hasStopped)\n            return;\n        if (!animationDriver)\n            animationDriver = driver(tick);\n        const now = animationDriver.now();\n        onPlay && onPlay();\n        if (holdTime !== null) {\n            startTime = now - holdTime;\n        }\n        else if (!startTime || playState === \"finished\") {\n            startTime = now;\n        }\n        if (playState === \"finished\") {\n            updateFinishedPromise();\n        }\n        cancelTime = startTime;\n        holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        playState = \"running\";\n        animationDriver.start();\n    };\n    if (autoplay) {\n        play();\n    }\n    const controls = {\n        then(resolve, reject) {\n            return currentFinishedPromise.then(resolve, reject);\n        },\n        get time() {\n            return millisecondsToSeconds(currentTime);\n        },\n        set time(newTime) {\n            newTime = secondsToMilliseconds(newTime);\n            currentTime = newTime;\n            if (holdTime !== null || !animationDriver || speed === 0) {\n                holdTime = newTime;\n            }\n            else {\n                startTime = animationDriver.now() - newTime / speed;\n            }\n        },\n        get duration() {\n            const duration = generator.calculatedDuration === null\n                ? calcGeneratorDuration(generator)\n                : generator.calculatedDuration;\n            return millisecondsToSeconds(duration);\n        },\n        get speed() {\n            return speed;\n        },\n        set speed(newSpeed) {\n            if (newSpeed === speed || !animationDriver)\n                return;\n            speed = newSpeed;\n            controls.time = millisecondsToSeconds(currentTime);\n        },\n        get state() {\n            return playState;\n        },\n        play,\n        pause: () => {\n            playState = \"paused\";\n            holdTime = currentTime;\n        },\n        stop: () => {\n            hasStopped = true;\n            if (playState === \"idle\")\n                return;\n            playState = \"idle\";\n            onStop && onStop();\n            cancel();\n        },\n        cancel: () => {\n            if (cancelTime !== null)\n                tick(cancelTime);\n            cancel();\n        },\n        complete: () => {\n            playState = \"finished\";\n        },\n        sample: (elapsed) => {\n            startTime = 0;\n            return tick(elapsed);\n        },\n    };\n    return controls;\n}\n\nexport { animateValue };\n"],"names":["types","inertia","keyframes","spring","animateValue","autoplay","delay","driver","frameloopDriver","keyframes$1","type","repeat","repeatDelay","repeatType","onPlay","onStop","onComplete","onUpdate","options","speed","hasStopped","resolveFinishedPromise","currentFinishedPromise","updateFinishedPromise","resolve","animationDriver","generatorFactory","mapNumbersToKeyframes","interpolate","generator","mirroredGenerator","playState","holdTime","startTime","cancelTime","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","currentTime","tick","timestamp","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","iterationIsOdd","p","clamp","state","done","isAnimationFinished","finish","stopAnimationDriver","cancel","play","now","controls","reject","millisecondsToSeconds","newTime","secondsToMilliseconds","duration","newSpeed"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra213.cjs","sources":["../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.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: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[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, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    const initialVelocity = velocity ? -millisecondsToSeconds(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 ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\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    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 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 = calcGeneratorVelocity(resolveSpring, t, current);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\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    };\n}\n\nexport { spring };\n"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","key","getSpringOptions","springOptions","derived","findSpring","spring","keyframes","restDelta","restSpeed","origin","target","state","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","initialVelocity","millisecondsToSeconds","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","calcAngularFreq","t","envelope","dampedAngularFreq","freqForT","current","currentVelocity","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold"],"mappings":"uKAIMA,EAAe,CAAC,WAAY,QAAQ,EACpCC,EAAc,CAAC,YAAa,UAAW,MAAM,EACnD,SAASC,EAAaC,EAASC,EAAM,CACjC,OAAOA,EAAK,KAAMC,GAAQF,EAAQE,CAAG,IAAM,MAAS,CACxD,CACA,SAASC,EAAiBH,EAAS,CAC/B,IAAII,EAAgB,CAChB,SAAU,EACV,UAAW,IACX,QAAS,GACT,KAAM,EACN,uBAAwB,GACxB,GAAGJ,CACX,EAEI,GAAI,CAACD,EAAaC,EAASF,CAAW,GAClCC,EAAaC,EAASH,CAAY,EAAG,CACrC,MAAMQ,EAAUC,aAAWN,CAAO,EAClCI,EAAgB,CACZ,GAAGA,EACH,GAAGC,EACH,SAAU,EACV,KAAM,CAClB,EACQD,EAAc,uBAAyB,EAC1C,CACD,OAAOA,CACX,CACA,SAASG,EAAO,CAAE,UAAAC,EAAW,UAAAC,EAAW,UAAAC,EAAW,GAAGV,CAAO,EAAI,CAC7D,MAAMW,EAASH,EAAU,CAAC,EACpBI,EAASJ,EAAUA,EAAU,OAAS,CAAC,EAKvCK,EAAQ,CAAE,KAAM,GAAO,MAAOF,CAAM,EACpC,CAAE,UAAAG,EAAW,QAAAC,EAAS,KAAAC,EAAMC,SAAAA,EAAU,SAAAC,EAAU,uBAAAC,CAAyB,EAAGhB,EAAiBH,CAAO,EACpGoB,EAAkBH,EAAW,CAACI,EAAqB,sBAACJ,CAAQ,EAAI,EAChEK,EAAeP,GAAW,EAAI,KAAK,KAAKD,EAAYE,CAAI,GACxDO,EAAeX,EAASD,EACxBa,EAAsBH,EAAAA,sBAAsB,KAAK,KAAKP,EAAYE,CAAI,CAAC,EAQvES,EAAkB,KAAK,IAAIF,CAAY,EAAI,EACjDb,IAAcA,EAAYe,EAAkB,IAAO,GACnDhB,IAAcA,EAAYgB,EAAkB,KAAQ,IACpD,IAAIC,EACJ,GAAIJ,EAAe,EAAG,CAClB,MAAMK,EAAcC,EAAAA,gBAAgBJ,EAAqBF,CAAY,EAErEI,EAAiBG,GAAM,CACnB,MAAMC,EAAW,KAAK,IAAI,CAACR,EAAeE,EAAsBK,CAAC,EACjE,OAAQjB,EACJkB,IACOV,EACCE,EAAeE,EAAsBD,GACrCI,EACA,KAAK,IAAIA,EAAcE,CAAC,EACxBN,EAAe,KAAK,IAAII,EAAcE,CAAC,EAC/D,CACK,SACQP,IAAiB,EAEtBI,EAAiBG,GAAMjB,EACnB,KAAK,IAAI,CAACY,EAAsBK,CAAC,GAC5BN,GACIH,EAAkBI,EAAsBD,GAAgBM,OAEpE,CAED,MAAME,EAAoBP,EAAsB,KAAK,KAAKF,EAAeA,EAAe,CAAC,EACzFI,EAAiBG,GAAM,CACnB,MAAMC,EAAW,KAAK,IAAI,CAACR,EAAeE,EAAsBK,CAAC,EAE3DG,EAAW,KAAK,IAAID,EAAoBF,EAAG,GAAG,EACpD,OAAQjB,EACHkB,IACKV,EACEE,EAAeE,EAAsBD,GACrC,KAAK,KAAKS,CAAQ,EAClBD,EACIR,EACA,KAAK,KAAKS,CAAQ,GAC1BD,CACpB,CACK,CACD,MAAO,CACH,mBAAoBZ,GAAyBD,GAAY,KACzD,KAAOW,GAAM,CACT,MAAMI,EAAUP,EAAcG,CAAC,EAC/B,GAAKV,EAqBDN,EAAM,KAAOgB,GAAKX,MArBO,CACzB,IAAIgB,EAAkBd,EAClBS,IAAM,IAMFP,EAAe,EACfY,EAAkBC,EAAAA,sBAAsBT,EAAeG,EAAGI,CAAO,EAGjEC,EAAkB,GAG1B,MAAME,EAA2B,KAAK,IAAIF,CAAe,GAAKxB,EACxD2B,EAA+B,KAAK,IAAIzB,EAASqB,CAAO,GAAKxB,EACnEI,EAAM,KACFuB,GAA4BC,CACnC,CAID,OAAAxB,EAAM,MAAQA,EAAM,KAAOD,EAASqB,EAC7BpB,CACV,CACT,CACA","x_google_ignoreList":[0]}

package/dist/lyra213.js

@@ -1,121 +1,65 @@
-import { keyframes as y } from "./lyra214.js";
-import { spring as ee } from "./lyra215.js";
-import { inertia as T } from "./lyra216.js";
-import { frameloopDriver as te } from "./lyra217.js";
-import { interpolate as ie } from "./lyra218.js";
-import { clamp as ne } from "./lyra219.js";
-import { millisecondsToSeconds as A, secondsToMilliseconds as re } from "./lyra220.js";
-import { calcGeneratorDuration as X } from "./lyra221.js";
-const le = {
-  decay: T,
-  inertia: T,
-  tween: y,
-  keyframes: y,
-  spring: ee
-};
-function he({ autoplay: Y = !0, delay: Z = 0, driver: _ = te, keyframes: u, type: C = "keyframes", repeat: h = 0, repeatDelay: p = 0, repeatType: v = "loop", onPlay: B, onStop: K, onComplete: N, onUpdate: O, ...M }) {
-  let r = 1, S = !1, F, V;
-  const I = () => {
-    V = new Promise((e) => {
-      F = e;
-    });
+import { millisecondsToSeconds as F } from "./lyra218.js";
+import { calcGeneratorVelocity as R } from "./lyra232.js";
+import { findSpring as S, calcAngularFreq as V } from "./lyra233.js";
+const A = ["duration", "bounce"], w = ["stiffness", "damping", "mass"];
+function x(e, t) {
+  return t.some((r) => e[r] !== void 0);
+}
+function B(e) {
+  let t = {
+    velocity: 0,
+    stiffness: 100,
+    damping: 10,
+    mass: 1,
+    isResolvedFromDuration: !1,
+    ...e
   };
-  I();
-  let l;
-  const P = le[C] || y;
-  let x;
-  P !== y && typeof u[0] != "number" && (x = ie([0, 100], u, {
-    clamp: !1
-  }), u = [0, 100]);
-  const s = P({ ...M, keyframes: u });
-  let W;
-  v === "mirror" && (W = P({
-    ...M,
-    keyframes: [...u].reverse(),
-    velocity: -(M.velocity || 0)
-  }));
-  let i = "idle", o = null, n = null, g = null;
-  s.calculatedDuration === null && h && (s.calculatedDuration = X(s));
-  const { calculatedDuration: G } = s;
-  let c = 1 / 0, f = 1 / 0;
-  G !== null && (c = G + p, f = c * (h + 1) - p);
-  let t = 0;
-  const b = (e) => {
-    if (n === null)
-      return;
-    r > 0 && (n = Math.min(n, e)), r < 0 && (n = Math.min(e - f / r, n)), o !== null ? t = o : t = Math.round(e - n) * r;
-    const m = t - Z * (r >= 0 ? 1 : -1), E = r >= 0 ? m < 0 : m > f;
-    t = Math.max(m, 0), i === "finished" && o === null && (t = f);
-    let H = t, J = s;
-    if (h) {
-      const k = t / c;
-      let D = Math.floor(k), a = k % 1;
-      !a && k >= 1 && (a = 1), a === 1 && D--, D = Math.min(D, h + 1);
-      const Q = !!(D % 2);
-      Q && (v === "reverse" ? (a = 1 - a, p && (a -= p / c)) : v === "mirror" && (J = W));
-      let R = ne(0, 1, a);
-      t > f && (R = v === "reverse" && Q ? 1 : 0), H = R * c;
+  if (!x(e, w) && x(e, A)) {
+    const r = S(e);
+    t = {
+      ...t,
+      ...r,
+      velocity: 0,
+      mass: 1
+    }, t.isResolvedFromDuration = !0;
+  }
+  return t;
+}
+function j({ keyframes: e, restDelta: t, restSpeed: r, ...T }) {
+  const m = e[0], c = e[e.length - 1], u = { done: !1, value: m }, { stiffness: p, damping: b, mass: g, velocity: M, duration: v, isResolvedFromDuration: y } = B(T), h = M ? -F(M) : 0, s = b / (2 * Math.sqrt(p * g)), a = c - m, i = F(Math.sqrt(p / g)), q = Math.abs(a) < 5;
+  r || (r = q ? 0.01 : 2), t || (t = q ? 5e-3 : 0.5);
+  let d;
+  if (s < 1) {
+    const n = V(i, s);
+    d = (o) => {
+      const l = Math.exp(-s * i * o);
+      return c - l * ((h + s * i * a) / n * Math.sin(n * o) + a * Math.cos(n * o));
+    };
+  } else if (s === 1)
+    d = (n) => c - Math.exp(-i * n) * (a + (h + i * a) * n);
+  else {
+    const n = i * Math.sqrt(s * s - 1);
+    d = (o) => {
+      const l = Math.exp(-s * i * o), f = Math.min(n * o, 300);
+      return c - l * ((h + s * i * a) * Math.sinh(f) + n * a * Math.cosh(f)) / n;
+    };
+  }
+  return {
+    calculatedDuration: y && v || null,
+    next: (n) => {
+      const o = d(n);
+      if (y)
+        u.done = n >= v;
+      else {
+        let l = h;
+        n !== 0 && (s < 1 ? l = R(d, n, o) : l = 0);
+        const f = Math.abs(l) <= r, D = Math.abs(c - o) <= t;
+        u.done = f && D;
+      }
+      return u.value = u.done ? c : o, u;
     }
-    const d = E ? { done: !1, value: u[0] } : J.next(H);
-    x && (d.value = x(d.value));
-    let { done: L } = d;
-    !E && G !== null && (L = r >= 0 ? t >= f : t <= 0);
-    const $ = o === null && (i === "finished" || i === "running" && L);
-    return O && O(d.value), $ && U(), d;
-  }, j = () => {
-    l && l.stop(), l = void 0;
-  }, q = () => {
-    i = "idle", j(), F(), I(), n = g = null;
-  }, U = () => {
-    i = "finished", N && N(), j(), F();
-  }, w = () => {
-    if (S)
-      return;
-    l || (l = _(b));
-    const e = l.now();
-    B && B(), o !== null ? n = e - o : (!n || i === "finished") && (n = e), i === "finished" && I(), g = n, o = null, i = "running", l.start();
-  };
-  Y && w();
-  const z = {
-    then(e, m) {
-      return V.then(e, m);
-    },
-    get time() {
-      return A(t);
-    },
-    set time(e) {
-      e = re(e), t = e, o !== null || !l || r === 0 ? o = e : n = l.now() - e / r;
-    },
-    get duration() {
-      const e = s.calculatedDuration === null ? X(s) : s.calculatedDuration;
-      return A(e);
-    },
-    get speed() {
-      return r;
-    },
-    set speed(e) {
-      e === r || !l || (r = e, z.time = A(t));
-    },
-    get state() {
-      return i;
-    },
-    play: w,
-    pause: () => {
-      i = "paused", o = t;
-    },
-    stop: () => {
-      S = !0, i !== "idle" && (i = "idle", K && K(), q());
-    },
-    cancel: () => {
-      g !== null && b(g), q();
-    },
-    complete: () => {
-      i = "finished";
-    },
-    sample: (e) => (n = 0, b(e))
   };
-  return z;
 }
 export {
-  he as animateValue
+  j as spring
 };

package/dist/lyra213.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra213.js","sources":["../node_modules/framer-motion/dist/es/animation/animators/js/index.mjs"],"sourcesContent":["import { keyframes } from '../../generators/keyframes.mjs';\nimport { spring } from '../../generators/spring/index.mjs';\nimport { inertia } from '../../generators/inertia.mjs';\nimport { frameloopDriver } from './driver-frameloop.mjs';\nimport { interpolate } from '../../../utils/interpolate.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorDuration } from '../../generators/utils/calc-duration.mjs';\n\nconst types = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\n/**\n * Animate a single value on the main thread.\n *\n * This function is written, where functionality overlaps,\n * to be largely spec-compliant with WAAPI to allow fungibility\n * between the two.\n */\nfunction animateValue({ autoplay = true, delay = 0, driver = frameloopDriver, keyframes: keyframes$1, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", onPlay, onStop, onComplete, onUpdate, ...options }) {\n    let speed = 1;\n    let hasStopped = false;\n    let resolveFinishedPromise;\n    let currentFinishedPromise;\n    /**\n     * Resolve the current Promise every time we enter the\n     * finished state. This is WAAPI-compatible behaviour.\n     */\n    const updateFinishedPromise = () => {\n        currentFinishedPromise = new Promise((resolve) => {\n            resolveFinishedPromise = resolve;\n        });\n    };\n    // Create the first finished promise\n    updateFinishedPromise();\n    let animationDriver;\n    const generatorFactory = types[type] || keyframes;\n    /**\n     * If this isn't the keyframes generator and we've been provided\n     * strings as keyframes, we need to interpolate these.\n     * TODO: Support velocity for units and complex value types/\n     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        mapNumbersToKeyframes = interpolate([0, 100], keyframes$1, {\n            clamp: false,\n        });\n        keyframes$1 = [0, 100];\n    }\n    const generator = generatorFactory({ ...options, keyframes: keyframes$1 });\n    let mirroredGenerator;\n    if (repeatType === \"mirror\") {\n        mirroredGenerator = generatorFactory({\n            ...options,\n            keyframes: [...keyframes$1].reverse(),\n            velocity: -(options.velocity || 0),\n        });\n    }\n    let playState = \"idle\";\n    let holdTime = null;\n    let startTime = null;\n    let cancelTime = null;\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 && repeat) {\n        generator.calculatedDuration = calcGeneratorDuration(generator);\n    }\n    const { calculatedDuration } = generator;\n    let resolvedDuration = Infinity;\n    let totalDuration = Infinity;\n    if (calculatedDuration !== null) {\n        resolvedDuration = calculatedDuration + repeatDelay;\n        totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n    }\n    let currentTime = 0;\n    const tick = (timestamp) => {\n        if (startTime === null)\n            return;\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 (speed > 0)\n            startTime = Math.min(startTime, timestamp);\n        if (speed < 0)\n            startTime = Math.min(timestamp - totalDuration / speed, startTime);\n        if (holdTime !== null) {\n            currentTime = 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            currentTime = Math.round(timestamp - startTime) * speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = currentTime - delay * (speed >= 0 ? 1 : -1);\n        const isInDelayPhase = speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;\n        currentTime = Math.max(timeWithoutDelay, 0);\n        /**\n         * If this animation has finished, set the current time\n         * to the total duration.\n         */\n        if (playState === \"finished\" && holdTime === null) {\n            currentTime = totalDuration;\n        }\n        let elapsed = 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 = currentTime / 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 iterationIsOdd = Boolean(currentIteration % 2);\n            if (iterationIsOdd) {\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            let p = clamp(0, 1, iterationProgress);\n            if (currentTime > totalDuration) {\n                p = repeatType === \"reverse\" && iterationIsOdd ? 1 : 0;\n            }\n            elapsed = p * 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        const state = isInDelayPhase\n            ? { done: false, value: keyframes$1[0] }\n            : frameGenerator.next(elapsed);\n        if (mapNumbersToKeyframes) {\n            state.value = mapNumbersToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done = speed >= 0 ? currentTime >= totalDuration : currentTime <= 0;\n        }\n        const isAnimationFinished = holdTime === null &&\n            (playState === \"finished\" || (playState === \"running\" && done));\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            finish();\n        }\n        return state;\n    };\n    const stopAnimationDriver = () => {\n        animationDriver && animationDriver.stop();\n        animationDriver = undefined;\n    };\n    const cancel = () => {\n        playState = \"idle\";\n        stopAnimationDriver();\n        resolveFinishedPromise();\n        updateFinishedPromise();\n        startTime = cancelTime = null;\n    };\n    const finish = () => {\n        playState = \"finished\";\n        onComplete && onComplete();\n        stopAnimationDriver();\n        resolveFinishedPromise();\n    };\n    const play = () => {\n        if (hasStopped)\n            return;\n        if (!animationDriver)\n            animationDriver = driver(tick);\n        const now = animationDriver.now();\n        onPlay && onPlay();\n        if (holdTime !== null) {\n            startTime = now - holdTime;\n        }\n        else if (!startTime || playState === \"finished\") {\n            startTime = now;\n        }\n        if (playState === \"finished\") {\n            updateFinishedPromise();\n        }\n        cancelTime = startTime;\n        holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        playState = \"running\";\n        animationDriver.start();\n    };\n    if (autoplay) {\n        play();\n    }\n    const controls = {\n        then(resolve, reject) {\n            return currentFinishedPromise.then(resolve, reject);\n        },\n        get time() {\n            return millisecondsToSeconds(currentTime);\n        },\n        set time(newTime) {\n            newTime = secondsToMilliseconds(newTime);\n            currentTime = newTime;\n            if (holdTime !== null || !animationDriver || speed === 0) {\n                holdTime = newTime;\n            }\n            else {\n                startTime = animationDriver.now() - newTime / speed;\n            }\n        },\n        get duration() {\n            const duration = generator.calculatedDuration === null\n                ? calcGeneratorDuration(generator)\n                : generator.calculatedDuration;\n            return millisecondsToSeconds(duration);\n        },\n        get speed() {\n            return speed;\n        },\n        set speed(newSpeed) {\n            if (newSpeed === speed || !animationDriver)\n                return;\n            speed = newSpeed;\n            controls.time = millisecondsToSeconds(currentTime);\n        },\n        get state() {\n            return playState;\n        },\n        play,\n        pause: () => {\n            playState = \"paused\";\n            holdTime = currentTime;\n        },\n        stop: () => {\n            hasStopped = true;\n            if (playState === \"idle\")\n                return;\n            playState = \"idle\";\n            onStop && onStop();\n            cancel();\n        },\n        cancel: () => {\n            if (cancelTime !== null)\n                tick(cancelTime);\n            cancel();\n        },\n        complete: () => {\n            playState = \"finished\";\n        },\n        sample: (elapsed) => {\n            startTime = 0;\n            return tick(elapsed);\n        },\n    };\n    return controls;\n}\n\nexport { animateValue };\n"],"names":["types","inertia","keyframes","spring","animateValue","autoplay","delay","driver","frameloopDriver","keyframes$1","type","repeat","repeatDelay","repeatType","onPlay","onStop","onComplete","onUpdate","options","speed","hasStopped","resolveFinishedPromise","currentFinishedPromise","updateFinishedPromise","resolve","animationDriver","generatorFactory","mapNumbersToKeyframes","interpolate","generator","mirroredGenerator","playState","holdTime","startTime","cancelTime","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","currentTime","tick","timestamp","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","iterationIsOdd","p","clamp","state","done","isAnimationFinished","finish","stopAnimationDriver","cancel","play","now","controls","reject","millisecondsToSeconds","newTime","secondsToMilliseconds","duration","newSpeed"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra213.js","sources":["../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.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: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[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, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    const initialVelocity = velocity ? -millisecondsToSeconds(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 ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\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    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 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 = calcGeneratorVelocity(resolveSpring, t, current);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\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    };\n}\n\nexport { spring };\n"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","key","getSpringOptions","springOptions","derived","findSpring","spring","keyframes","restDelta","restSpeed","origin","target","state","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","initialVelocity","millisecondsToSeconds","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","calcAngularFreq","t","envelope","dampedAngularFreq","freqForT","current","currentVelocity","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lyra214.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("./lyra249.cjs"),g=require("./lyra301.cjs"),a=require("./lyra302.cjs"),p=require("./lyra218.cjs"),T=require("./lyra303.cjs"),d=require("./lyra304.cjs");function c(n,e){return n.map(()=>e||l.easeInOut).splice(0,n.length-1)}function m({duration:n=300,keyframes:e,times:t,ease:i="easeInOut"}){const r=g.isEasingArray(i)?i.map(a.easingDefinitionToFunction):a.easingDefinitionToFunction(i),o={done:!1,value:e[0]},u=d.convertOffsetToTimes(t&&t.length===e.length?t:T.defaultOffset(e),n),f=p.interpolate(u,e,{ease:Array.isArray(r)?r:c(e,r)});return{calculatedDuration:n,next:s=>(o.value=f(s),o.done=s>=n,o)}}exports.defaultEasing=c;exports.keyframes=m;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const C=require("./lyra213.cjs"),D=require("./lyra232.cjs");function G({keyframes:g,velocity:b=0,power:M=.8,timeConstant:B=325,bounceDamping:O=10,bounceStiffness:k=500,modifyTarget:d,min:n,max:a,restDelta:f=.5,restSpeed:q}){const c=g[0],t={done:!1,value:c},F=e=>n!==void 0&&e<n||a!==void 0&&e>a,S=e=>n===void 0?a:a===void 0||Math.abs(n-e)<Math.abs(a-e)?n:a;let s=M*b;const o=c+s,u=d===void 0?o:d(o);u!==o&&(s=u-c);const y=e=>-s*Math.exp(-e/B),p=e=>u+y(e),h=e=>{const i=y(e),j=p(e);t.done=Math.abs(i)<=f,t.value=t.done?u:j};let r,l;const v=e=>{F(t.value)&&(r=e,l=C.spring({keyframes:[t.value,S(t.value)],velocity:D.calcGeneratorVelocity(p,e,t.value),damping:O,stiffness:k,restDelta:f,restSpeed:q}))};return v(0),{calculatedDuration:null,next:e=>{let i=!1;return!l&&r===void 0&&(i=!0,h(e),v(e)),r!==void 0&&e>r?l.next(e-r):(!i&&h(e),t)}}}exports.inertia=G;

package/dist/lyra214.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra214.cjs","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":["defaultEasing","values","easing","easeInOut","keyframes","duration","keyframeValues","times","ease","easingFunctions","isEasingArray","easingDefinitionToFunction","state","absoluteTimes","convertOffsetToTimes","defaultOffset","mapTimeToKeyframe","interpolate","t"],"mappings":"wPAOA,SAASA,EAAcC,EAAQC,EAAQ,CACnC,OAAOD,EAAO,IAAI,IAAMC,GAAUC,EAAS,SAAA,EAAE,OAAO,EAAGF,EAAO,OAAS,CAAC,CAC5E,CACA,SAASG,EAAU,CAAE,SAAAC,EAAW,IAAK,UAAWC,EAAgB,MAAAC,EAAO,KAAAC,EAAO,aAAgB,CAK1F,MAAMC,EAAkBC,EAAa,cAACF,CAAI,EACpCA,EAAK,IAAIG,4BAA0B,EACnCA,EAA0B,2BAACH,CAAI,EAK/BI,EAAQ,CACV,KAAM,GACN,MAAON,EAAe,CAAC,CAC/B,EAIUO,EAAgBC,EAAoB,qBAG1CP,GAASA,EAAM,SAAWD,EAAe,OACnCC,EACAQ,gBAAcT,CAAc,EAAGD,CAAQ,EACvCW,EAAoBC,EAAAA,YAAYJ,EAAeP,EAAgB,CACjE,KAAM,MAAM,QAAQG,CAAe,EAC7BA,EACAT,EAAcM,EAAgBG,CAAe,CAC3D,CAAK,EACD,MAAO,CACH,mBAAoBJ,EACpB,KAAOa,IACHN,EAAM,MAAQI,EAAkBE,CAAC,EACjCN,EAAM,KAAOM,GAAKb,EACXO,EAEnB,CACA","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra214.cjs","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),\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":["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","calcGeneratorVelocity","hasUpdatedFrame"],"mappings":"4IAGA,SAASA,EAAQ,CAAE,UAAAC,EAAS,SAAEC,EAAW,EAAK,MAAAC,EAAQ,GAAK,aAAAC,EAAe,IAAK,cAAAC,EAAgB,GAAI,gBAAAC,EAAkB,IAAK,aAAAC,EAAc,IAAAC,EAAK,IAAAC,EAAK,UAAAC,EAAY,GAAK,UAAAC,GAAc,CAC7K,MAAMC,EAASX,EAAU,CAAC,EACpBY,EAAQ,CACV,KAAM,GACN,MAAOD,CACf,EACUE,EAAiBC,GAAOP,IAAQ,QAAaO,EAAIP,GAASC,IAAQ,QAAaM,EAAIN,EACnFO,EAAmBD,GACjBP,IAAQ,OACDC,EACPA,IAAQ,QAEL,KAAK,IAAID,EAAMO,CAAC,EAAI,KAAK,IAAIN,EAAMM,CAAC,EADhCP,EAC0CC,EAEzD,IAAIQ,EAAYd,EAAQD,EACxB,MAAMgB,EAAQN,EAASK,EACjBE,EAASZ,IAAiB,OAAYW,EAAQX,EAAaW,CAAK,EAKlEC,IAAWD,IACXD,EAAYE,EAASP,GACzB,MAAMQ,EAAaC,GAAM,CAACJ,EAAY,KAAK,IAAI,CAACI,EAAIjB,CAAY,EAC1DkB,EAAcD,GAAMF,EAASC,EAAUC,CAAC,EACxCE,EAAiBF,GAAM,CACzB,MAAMG,EAAQJ,EAAUC,CAAC,EACnBI,EAASH,EAAWD,CAAC,EAC3BR,EAAM,KAAO,KAAK,IAAIW,CAAK,GAAKd,EAChCG,EAAM,MAAQA,EAAM,KAAOM,EAASM,CAC5C,EAOI,IAAIC,EACAC,EACJ,MAAMC,EAAsBP,GAAM,CACzBP,EAAcD,EAAM,KAAK,IAE9Ba,EAAsBL,EACtBM,EAAWE,EAAAA,OAAO,CACd,UAAW,CAAChB,EAAM,MAAOG,EAAgBH,EAAM,KAAK,CAAC,EACrD,SAAUiB,EAAAA,sBAAsBR,EAAYD,EAAGR,EAAM,KAAK,EAC1D,QAASR,EACT,UAAWC,EACX,UAAAI,EACA,UAAAC,CACZ,CAAS,EACT,EACI,OAAAiB,EAAmB,CAAC,EACb,CACH,mBAAoB,KACpB,KAAOP,GAAM,CAOT,IAAIU,EAAkB,GAUtB,MATI,CAACJ,GAAYD,IAAwB,SACrCK,EAAkB,GAClBR,EAAcF,CAAC,EACfO,EAAmBP,CAAC,GAMpBK,IAAwB,QAAaL,EAAIK,EAClCC,EAAS,KAAKN,EAAIK,CAAmB,GAG5C,CAACK,GAAmBR,EAAcF,CAAC,EAC5BR,EAEd,CACT,CACA","x_google_ignoreList":[0]}

package/dist/lyra214.js

@@ -1,30 +1,36 @@
-import { easeInOut as c } from "./lyra249.js";
-import { isEasingArray as p } from "./lyra301.js";
-import { easingDefinitionToFunction as m } from "./lyra302.js";
-import { interpolate as u } from "./lyra218.js";
-import { defaultOffset as l } from "./lyra303.js";
-import { convertOffsetToTimes as g } from "./lyra304.js";
-function T(n, t) {
-  return n.map(() => t || c).splice(0, n.length - 1);
-}
-function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
-  const e = p(r) ? r.map(m) : m(r), i = {
+import { spring as L } from "./lyra213.js";
+import { calcGeneratorVelocity as R } from "./lyra232.js";
+function $({ keyframes: g, velocity: B = 0, power: M = 0.8, timeConstant: b = 325, bounceDamping: k = 10, bounceStiffness: F = 500, modifyTarget: l, min: t, max: a, restDelta: f = 0.5, restSpeed: O }) {
+  const s = g[0], n = {
     done: !1,
-    value: t[0]
-  }, s = g(
-    // 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 : l(t),
-    n
-  ), a = u(s, t, {
-    ease: Array.isArray(e) ? e : T(t, e)
-  });
-  return {
-    calculatedDuration: n,
-    next: (f) => (i.value = a(f), i.done = f >= n, i)
+    value: s
+  }, C = (e) => t !== void 0 && e < t || a !== void 0 && e > a, D = (e) => t === void 0 ? a : a === void 0 || Math.abs(t - e) < Math.abs(a - e) ? t : a;
+  let c = M * B;
+  const d = s + c, u = l === void 0 ? d : l(d);
+  u !== d && (c = u - s);
+  const p = (e) => -c * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
+    const o = p(e), G = h(e);
+    n.done = Math.abs(o) <= f, n.value = n.done ? u : G;
+  };
+  let r, i;
+  const v = (e) => {
+    C(n.value) && (r = e, i = L({
+      keyframes: [n.value, D(n.value)],
+      velocity: R(h, e, n.value),
+      damping: k,
+      stiffness: F,
+      restDelta: f,
+      restSpeed: O
+    }));
+  };
+  return v(0), {
+    calculatedDuration: null,
+    next: (e) => {
+      let o = !1;
+      return !i && r === void 0 && (o = !0, y(e), v(e)), r !== void 0 && e > r ? i.next(e - r) : (!o && y(e), n);
+    }
   };
 }
 export {
-  T as defaultEasing,
-  y as keyframes
+  $ as inertia
 };

package/dist/lyra214.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra214.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":["defaultEasing","values","easing","easeInOut","keyframes","duration","keyframeValues","times","ease","easingFunctions","isEasingArray","easingDefinitionToFunction","state","absoluteTimes","convertOffsetToTimes","defaultOffset","mapTimeToKeyframe","interpolate","t"],"mappings":";;;;;;AAOA,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]}
+{"version":3,"file":"lyra214.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),\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":["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","calcGeneratorVelocity","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,EAC5C;AAOI,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,EAAsBR,GAAYD,GAAGR,EAAM,KAAK;AAAA,MAC1D,SAASR;AAAA,MACT,WAAWC;AAAA,MACX,WAAAI;AAAA,MACA,WAAAC;AAAA,IACZ,CAAS;AAAA,EACT;AACI,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,IAAIK,IAClCC,EAAS,KAAKN,IAAIK,CAAmB,KAG5C,CAACK,KAAmBR,EAAcF,CAAC,GAC5BR;AAAA,IAEd;AAAA,EACT;AACA;","x_google_ignoreList":[0]}

package/dist/lyra215.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const F=require("./lyra220.cjs"),R=require("./lyra234.cjs"),T=require("./lyra235.cjs"),V=["duration","bounce"],A=["stiffness","damping","mass"];function S(n,s){return s.some(r=>n[r]!==void 0)}function O(n){let s={velocity:0,stiffness:100,damping:10,mass:1,isResolvedFromDuration:!1,...n};if(!S(n,A)&&S(n,V)){const r=T.findSpring(n);s={...s,...r,velocity:0,mass:1},s.isResolvedFromDuration=!0}return s}function w({keyframes:n,restDelta:s,restSpeed:r,...b}){const f=n[0],l=n[n.length-1],u={done:!1,value:f},{stiffness:p,damping:x,mass:m,velocity:v,duration:M,isResolvedFromDuration:y}=O(b),h=v?-F.millisecondsToSeconds(v):0,t=x/(2*Math.sqrt(p*m)),a=l-f,o=F.millisecondsToSeconds(Math.sqrt(p/m)),q=Math.abs(a)<5;r||(r=q?.01:2),s||(s=q?.005:.5);let d;if(t<1){const e=T.calcAngularFreq(o,t);d=i=>{const c=Math.exp(-t*o*i);return l-c*((h+t*o*a)/e*Math.sin(e*i)+a*Math.cos(e*i))}}else if(t===1)d=e=>l-Math.exp(-o*e)*(a+(h+o*a)*e);else{const e=o*Math.sqrt(t*t-1);d=i=>{const c=Math.exp(-t*o*i),g=Math.min(e*i,300);return l-c*((h+t*o*a)*Math.sinh(g)+e*a*Math.cosh(g))/e}}return{calculatedDuration:y&&M||null,next:e=>{const i=d(e);if(y)u.done=e>=M;else{let c=h;e!==0&&(t<1?c=R.calcGeneratorVelocity(d,e,i):c=0);const g=Math.abs(c)<=r,D=Math.abs(l-i)<=s;u.done=g&&D}return u.value=u.done?l:i,u}}}exports.spring=w;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./lyra208.cjs"),o=a=>{const r=({timestamp:t})=>a(t);return{start:()=>e.frame.update(r,!0),stop:()=>e.cancelFrame(r),now:()=>e.frameData.isProcessing?e.frameData.timestamp:performance.now()}};exports.frameloopDriver=o;

package/dist/lyra215.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra215.cjs","sources":["../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.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: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[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, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    const initialVelocity = velocity ? -millisecondsToSeconds(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 ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\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    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 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 = calcGeneratorVelocity(resolveSpring, t, current);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\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    };\n}\n\nexport { spring };\n"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","key","getSpringOptions","springOptions","derived","findSpring","spring","keyframes","restDelta","restSpeed","origin","target","state","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","initialVelocity","millisecondsToSeconds","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","calcAngularFreq","t","envelope","dampedAngularFreq","freqForT","current","currentVelocity","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra215.cjs","sources":["../node_modules/framer-motion/dist/es/animation/animators/js/driver-frameloop.mjs"],"sourcesContent":["import { frame, cancelFrame, frameData } from '../../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: () => frame.update(passTimestamp, true),\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 : performance.now(),\n    };\n};\n\nexport { frameloopDriver };\n"],"names":["frameloopDriver","update","passTimestamp","timestamp","frame","cancelFrame","frameData"],"mappings":"iHAEMA,EAAmBC,GAAW,CAChC,MAAMC,EAAgB,CAAC,CAAE,UAAAC,CAAW,IAAKF,EAAOE,CAAS,EACzD,MAAO,CACH,MAAO,IAAMC,EAAK,MAAC,OAAOF,EAAe,EAAI,EAC7C,KAAM,IAAMG,EAAW,YAACH,CAAa,EAKrC,IAAK,IAAMI,EAAAA,UAAU,aAAeA,EAAS,UAAC,UAAY,YAAY,IAAK,CACnF,CACA","x_google_ignoreList":[0]}

package/dist/lyra215.js

@@ -1,65 +1,16 @@
-import { millisecondsToSeconds as F } from "./lyra220.js";
-import { calcGeneratorVelocity as R } from "./lyra234.js";
-import { findSpring as S, calcAngularFreq as V } from "./lyra235.js";
-const A = ["duration", "bounce"], w = ["stiffness", "damping", "mass"];
-function x(e, t) {
-  return t.some((r) => e[r] !== void 0);
-}
-function B(e) {
-  let t = {
-    velocity: 0,
-    stiffness: 100,
-    damping: 10,
-    mass: 1,
-    isResolvedFromDuration: !1,
-    ...e
-  };
-  if (!x(e, w) && x(e, A)) {
-    const r = S(e);
-    t = {
-      ...t,
-      ...r,
-      velocity: 0,
-      mass: 1
-    }, t.isResolvedFromDuration = !0;
-  }
-  return t;
-}
-function j({ keyframes: e, restDelta: t, restSpeed: r, ...T }) {
-  const m = e[0], c = e[e.length - 1], u = { done: !1, value: m }, { stiffness: p, damping: b, mass: g, velocity: M, duration: v, isResolvedFromDuration: y } = B(T), h = M ? -F(M) : 0, s = b / (2 * Math.sqrt(p * g)), a = c - m, i = F(Math.sqrt(p / g)), q = Math.abs(a) < 5;
-  r || (r = q ? 0.01 : 2), t || (t = q ? 5e-3 : 0.5);
-  let d;
-  if (s < 1) {
-    const n = V(i, s);
-    d = (o) => {
-      const l = Math.exp(-s * i * o);
-      return c - l * ((h + s * i * a) / n * Math.sin(n * o) + a * Math.cos(n * o));
-    };
-  } else if (s === 1)
-    d = (n) => c - Math.exp(-i * n) * (a + (h + i * a) * n);
-  else {
-    const n = i * Math.sqrt(s * s - 1);
-    d = (o) => {
-      const l = Math.exp(-s * i * o), f = Math.min(n * o, 300);
-      return c - l * ((h + s * i * a) * Math.sinh(f) + n * a * Math.cosh(f)) / n;
-    };
-  }
+import { frame as o, cancelFrame as m, frameData as e } from "./lyra208.js";
+const p = (t) => {
+  const r = ({ timestamp: a }) => t(a);
   return {
-    calculatedDuration: y && v || null,
-    next: (n) => {
-      const o = d(n);
-      if (y)
-        u.done = n >= v;
-      else {
-        let l = h;
-        n !== 0 && (s < 1 ? l = R(d, n, o) : l = 0);
-        const f = Math.abs(l) <= r, D = Math.abs(c - o) <= t;
-        u.done = f && D;
-      }
-      return u.value = u.done ? c : o, u;
-    }
+    start: () => o.update(r, !0),
+    stop: () => m(r),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => e.isProcessing ? e.timestamp : performance.now()
   };
-}
+};
 export {
-  j as spring
+  p as frameloopDriver
 };

package/dist/lyra215.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra215.js","sources":["../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.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: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[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, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    const initialVelocity = velocity ? -millisecondsToSeconds(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 ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\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    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 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 = calcGeneratorVelocity(resolveSpring, t, current);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\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    };\n}\n\nexport { spring };\n"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","key","getSpringOptions","springOptions","derived","findSpring","spring","keyframes","restDelta","restSpeed","origin","target","state","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","initialVelocity","millisecondsToSeconds","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","calcAngularFreq","t","envelope","dampedAngularFreq","freqForT","current","currentVelocity","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra215.js","sources":["../node_modules/framer-motion/dist/es/animation/animators/js/driver-frameloop.mjs"],"sourcesContent":["import { frame, cancelFrame, frameData } from '../../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: () => frame.update(passTimestamp, true),\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 : performance.now(),\n    };\n};\n\nexport { frameloopDriver };\n"],"names":["frameloopDriver","update","passTimestamp","timestamp","frame","cancelFrame","frameData"],"mappings":";AAEK,MAACA,IAAkB,CAACC,MAAW;AAChC,QAAMC,IAAgB,CAAC,EAAE,WAAAC,EAAW,MAAKF,EAAOE,CAAS;AACzD,SAAO;AAAA,IACH,OAAO,MAAMC,EAAM,OAAOF,GAAe,EAAI;AAAA,IAC7C,MAAM,MAAMG,EAAYH,CAAa;AAAA;AAAA;AAAA;AAAA;AAAA,IAKrC,KAAK,MAAMI,EAAU,eAAeA,EAAU,YAAY,YAAY,IAAK;AAAA,EACnF;AACA;","x_google_ignoreList":[0]}