@new-black/lyra 1.1.3 → 1.1.4

package/dist/lyra710.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra710.js","sources":["../node_modules/framer-motion/dist/es/value/index.mjs"],"sourcesContent":["import { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"11.0.3\";\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.canTrackVelocity = isFloat(this.current);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\n"],"names":["MAX_VELOCITY_DELTA","isFloat","value","MotionValue","init","options","v","render","currentTime","time","current","prevFrameValue","subscription","warnOnce","eventName","callback","SubscriptionManager","unsubscribe","frame","eventManagers","passiveEffect","stopPassiveEffect","prev","delta","velocityPerSecond","startAnimation","resolve","motionValue"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra710.js","sources":["../node_modules/framer-motion/dist/es/value/index.mjs"],"sourcesContent":["import { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"11.0.3\";\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.canTrackVelocity = isFloat(this.current);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\n"],"names":["MAX_VELOCITY_DELTA","isFloat","value","MotionValue","init","options","v","render","currentTime","time","current","prevFrameValue","subscription","warnOnce","eventName","callback","SubscriptionManager","unsubscribe","frame","eventManagers","passiveEffect","stopPassiveEffect","prev","delta","velocityPerSecond","startAnimation","resolve","motionValue"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lyra711.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra711.cjs","sources":["../node_modules/framer-motion/dist/es/value/use-will-change/is.mjs"],"sourcesContent":["import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n"],"names":["isWillChangeMotionValue","value","isMotionValue"],"mappings":"iHAEA,SAASA,EAAwBC,EAAO,CACpC,MAAO,GAAQC,EAAAA,cAAcD,CAAK,GAAKA,EAAM,IACjD","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra711.cjs","sources":["../node_modules/framer-motion/dist/es/value/use-will-change/is.mjs"],"sourcesContent":["import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n"],"names":["isWillChangeMotionValue","value","isMotionValue"],"mappings":"iHAEA,SAASA,EAAwBC,EAAO,CACpC,MAAO,GAAQC,EAAa,cAACD,CAAK,GAAKA,EAAM,IACjD","x_google_ignoreList":[0]}

package/dist/lyra715.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra715.cjs","sources":["../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs"],"sourcesContent":["import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.0.3\", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.0.3 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n"],"names":["updateMotionValuesFromProps","element","next","prev","willChange","key","nextValue","prevValue","isMotionValue","isWillChangeMotionValue","warnOnce","motionValue","existingValue","latestValue"],"mappings":"kMAKA,SAASA,EAA4BC,EAASC,EAAMC,EAAM,CACtD,KAAM,CAAE,WAAAC,CAAY,EAAGF,EACvB,UAAWG,KAAOH,EAAM,CACpB,MAAMI,EAAYJ,EAAKG,CAAG,EACpBE,EAAYJ,EAAKE,CAAG,EAC1B,GAAIG,EAAAA,cAAcF,CAAS,EAKvBL,EAAQ,SAASI,EAAKC,CAAS,EAC3BG,EAAAA,wBAAwBL,CAAU,GAClCA,EAAW,IAAIC,CAAG,EAMlB,QAAQ,IAAI,WAAa,eACzBK,WAASJ,EAAU,UAAY,SAAU,4CAA4CA,EAAU,OAAO,wCAAwC,UAG7IE,EAAAA,cAAcD,CAAS,EAK5BN,EAAQ,SAASI,EAAKM,EAAW,YAACL,EAAW,CAAE,MAAOL,CAAS,CAAA,CAAC,EAC5DQ,EAAAA,wBAAwBL,CAAU,GAClCA,EAAW,OAAOC,CAAG,UAGpBE,IAAcD,EAMnB,GAAIL,EAAQ,SAASI,CAAG,EAAG,CACvB,MAAMO,EAAgBX,EAAQ,SAASI,CAAG,EAE1C,CAACO,EAAc,aAAeA,EAAc,IAAIN,CAAS,CAC5D,KACI,CACD,MAAMO,EAAcZ,EAAQ,eAAeI,CAAG,EAC9CJ,EAAQ,SAASI,EAAKM,EAAAA,YAAYE,IAAgB,OAAYA,EAAcP,EAAW,CAAE,MAAOL,CAAO,CAAE,CAAC,CAC7G,CAER,CAED,UAAWI,KAAOF,EACVD,EAAKG,CAAG,IAAM,QACdJ,EAAQ,YAAYI,CAAG,EAE/B,OAAOH,CACX","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra715.cjs","sources":["../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs"],"sourcesContent":["import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.0.3\", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.0.3 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n"],"names":["updateMotionValuesFromProps","element","next","prev","willChange","key","nextValue","prevValue","isMotionValue","isWillChangeMotionValue","warnOnce","motionValue","existingValue","latestValue"],"mappings":"kMAKA,SAASA,EAA4BC,EAASC,EAAMC,EAAM,CACtD,KAAM,CAAE,WAAAC,CAAU,EAAKF,EACvB,UAAWG,KAAOH,EAAM,CACpB,MAAMI,EAAYJ,EAAKG,CAAG,EACpBE,EAAYJ,EAAKE,CAAG,EAC1B,GAAIG,EAAAA,cAAcF,CAAS,EAKvBL,EAAQ,SAASI,EAAKC,CAAS,EAC3BG,EAAAA,wBAAwBL,CAAU,GAClCA,EAAW,IAAIC,CAAG,EAMlB,QAAQ,IAAI,WAAa,eACzBK,WAASJ,EAAU,UAAY,SAAU,4CAA4CA,EAAU,OAAO,wCAAwC,UAG7IE,EAAAA,cAAcD,CAAS,EAK5BN,EAAQ,SAASI,EAAKM,EAAW,YAACL,EAAW,CAAE,MAAOL,CAAO,CAAE,CAAC,EAC5DQ,EAAAA,wBAAwBL,CAAU,GAClCA,EAAW,OAAOC,CAAG,UAGpBE,IAAcD,EAMnB,GAAIL,EAAQ,SAASI,CAAG,EAAG,CACvB,MAAMO,EAAgBX,EAAQ,SAASI,CAAG,EAE1C,CAACO,EAAc,aAAeA,EAAc,IAAIN,CAAS,CACzE,KACiB,CACD,MAAMO,EAAcZ,EAAQ,eAAeI,CAAG,EAC9CJ,EAAQ,SAASI,EAAKM,EAAAA,YAAYE,IAAgB,OAAYA,EAAcP,EAAW,CAAE,MAAOL,CAAS,CAAA,CAAC,CAC1H,CAEA,CAEI,UAAWI,KAAOF,EACVD,EAAKG,CAAG,IAAM,QACdJ,EAAQ,YAAYI,CAAG,EAE/B,OAAOH,CACX","x_google_ignoreList":[0]}

package/dist/lyra715.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra715.js","sources":["../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs"],"sourcesContent":["import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.0.3\", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.0.3 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n"],"names":["updateMotionValuesFromProps","element","next","prev","willChange","key","nextValue","prevValue","isMotionValue","isWillChangeMotionValue","warnOnce","motionValue","existingValue","latestValue"],"mappings":";;;;AAKA,SAASA,EAA4BC,GAASC,GAAMC,GAAM;AACtD,QAAM,EAAE,YAAAC,EAAY,IAAGF;AACvB,aAAWG,KAAOH,GAAM;AACpB,UAAMI,IAAYJ,EAAKG,CAAG,GACpBE,IAAYJ,EAAKE,CAAG;AAC1B,QAAIG,EAAcF,CAAS;AAKvB,MAAAL,EAAQ,SAASI,GAAKC,CAAS,GAC3BG,EAAwBL,CAAU,KAClCA,EAAW,IAAIC,CAAG,GAMlB,QAAQ,IAAI,aAAa,iBACzBK,EAASJ,EAAU,YAAY,UAAU,4CAA4CA,EAAU,OAAO,wCAAwC;AAAA,aAG7IE,EAAcD,CAAS;AAK5B,MAAAN,EAAQ,SAASI,GAAKM,EAAYL,GAAW,EAAE,OAAOL,EAAS,CAAA,CAAC,GAC5DQ,EAAwBL,CAAU,KAClCA,EAAW,OAAOC,CAAG;AAAA,aAGpBE,MAAcD;AAMnB,UAAIL,EAAQ,SAASI,CAAG,GAAG;AACvB,cAAMO,IAAgBX,EAAQ,SAASI,CAAG;AAE1C,SAACO,EAAc,eAAeA,EAAc,IAAIN,CAAS;AAAA,MAC5D,OACI;AACD,cAAMO,IAAcZ,EAAQ,eAAeI,CAAG;AAC9C,QAAAJ,EAAQ,SAASI,GAAKM,EAAYE,MAAgB,SAAYA,IAAcP,GAAW,EAAE,OAAOL,EAAO,CAAE,CAAC;AAAA,MAC7G;AAAA,EAER;AAED,aAAWI,KAAOF;AACd,IAAID,EAAKG,CAAG,MAAM,UACdJ,EAAQ,YAAYI,CAAG;AAE/B,SAAOH;AACX;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra715.js","sources":["../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs"],"sourcesContent":["import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.0.3\", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.0.3 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n"],"names":["updateMotionValuesFromProps","element","next","prev","willChange","key","nextValue","prevValue","isMotionValue","isWillChangeMotionValue","warnOnce","motionValue","existingValue","latestValue"],"mappings":";;;;AAKA,SAASA,EAA4BC,GAASC,GAAMC,GAAM;AACtD,QAAM,EAAE,YAAAC,EAAU,IAAKF;AACvB,aAAWG,KAAOH,GAAM;AACpB,UAAMI,IAAYJ,EAAKG,CAAG,GACpBE,IAAYJ,EAAKE,CAAG;AAC1B,QAAIG,EAAcF,CAAS;AAKvB,MAAAL,EAAQ,SAASI,GAAKC,CAAS,GAC3BG,EAAwBL,CAAU,KAClCA,EAAW,IAAIC,CAAG,GAMlB,QAAQ,IAAI,aAAa,iBACzBK,EAASJ,EAAU,YAAY,UAAU,4CAA4CA,EAAU,OAAO,wCAAwC;AAAA,aAG7IE,EAAcD,CAAS;AAK5B,MAAAN,EAAQ,SAASI,GAAKM,EAAYL,GAAW,EAAE,OAAOL,EAAO,CAAE,CAAC,GAC5DQ,EAAwBL,CAAU,KAClCA,EAAW,OAAOC,CAAG;AAAA,aAGpBE,MAAcD;AAMnB,UAAIL,EAAQ,SAASI,CAAG,GAAG;AACvB,cAAMO,IAAgBX,EAAQ,SAASI,CAAG;AAE1C,SAACO,EAAc,eAAeA,EAAc,IAAIN,CAAS;AAAA,MACzE,OACiB;AACD,cAAMO,IAAcZ,EAAQ,eAAeI,CAAG;AAC9C,QAAAJ,EAAQ,SAASI,GAAKM,EAAYE,MAAgB,SAAYA,IAAcP,GAAW,EAAE,OAAOL,EAAS,CAAA,CAAC;AAAA,MAC1H;AAAA,EAEA;AAEI,aAAWI,KAAOF;AACd,IAAID,EAAKG,CAAG,MAAM,UACdJ,EAAQ,YAAYI,CAAG;AAE/B,SAAOH;AACX;","x_google_ignoreList":[0]}

package/dist/lyra717.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=new Set;function c(t,n,r){t||o.has(n)||(console.warn(n),r&&console.warn(r),o.add(n))}exports.warnOnce=c;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=new Set;function r(t,n,o){t||e.has(n)||(console.warn(n),e.add(n))}exports.warnOnce=r;

package/dist/lyra717.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra717.cjs","sources":["../node_modules/framer-motion/dist/es/utils/warn-once.mjs"],"sourcesContent":["const warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n"],"names":["warned","warnOnce","condition","message","element"],"mappings":"gFAAA,MAAMA,EAAS,IAAI,IACnB,SAASC,EAASC,EAAWC,EAASC,EAAS,CACvCF,GAAaF,EAAO,IAAIG,CAAO,IAEnC,QAAQ,KAAKA,CAAO,EAChBC,GACA,QAAQ,KAAKA,CAAO,EACxBJ,EAAO,IAAIG,CAAO,EACtB","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra717.cjs","sources":["../node_modules/framer-motion/dist/es/utils/warn-once.mjs"],"sourcesContent":["const warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n"],"names":["warned","warnOnce","condition","message","element"],"mappings":"gFAAA,MAAMA,EAAS,IAAI,IACnB,SAASC,EAASC,EAAWC,EAASC,EAAS,CACvCF,GAAaF,EAAO,IAAIG,CAAO,IAEnC,QAAQ,KAAKA,CAAO,EAGpBH,EAAO,IAAIG,CAAO,EACtB","x_google_ignoreList":[0]}

package/dist/lyra717.js

@@ -1,7 +1,7 @@
-const r = /* @__PURE__ */ new Set();
-function w(c, n, o) {
-  c || r.has(n) || (console.warn(n), o && console.warn(o), r.add(n));
+const e = /* @__PURE__ */ new Set();
+function o(r, n, t) {
+  r || e.has(n) || (console.warn(n), e.add(n));
 }
 export {
-  w as warnOnce
+  o as warnOnce
 };

package/dist/lyra717.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra717.js","sources":["../node_modules/framer-motion/dist/es/utils/warn-once.mjs"],"sourcesContent":["const warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n"],"names":["warned","warnOnce","condition","message","element"],"mappings":"AAAA,MAAMA,IAAS,oBAAI;AACnB,SAASC,EAASC,GAAWC,GAASC,GAAS;AAC3C,EAAIF,KAAaF,EAAO,IAAIG,CAAO,MAEnC,QAAQ,KAAKA,CAAO,GAChBC,KACA,QAAQ,KAAKA,CAAO,GACxBJ,EAAO,IAAIG,CAAO;AACtB;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra717.js","sources":["../node_modules/framer-motion/dist/es/utils/warn-once.mjs"],"sourcesContent":["const warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n"],"names":["warned","warnOnce","condition","message","element"],"mappings":"AAAA,MAAMA,IAAS,oBAAI,IAAK;AACxB,SAASC,EAASC,GAAWC,GAASC,GAAS;AAC3C,EAAIF,KAAaF,EAAO,IAAIG,CAAO,MAEnC,QAAQ,KAAKA,CAAO,GAGpBH,EAAO,IAAIG,CAAO;AACtB;","x_google_ignoreList":[0]}

package/dist/lyra718.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra718.cjs","sources":["../node_modules/framer-motion/dist/es/motion/features/definitions.mjs"],"sourcesContent":["const featureProps = {\n    animation: [\n        \"animate\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"exit\",\n        \"whileInView\",\n        \"whileFocus\",\n        \"whileDrag\",\n    ],\n    exit: [\"exit\"],\n    drag: [\"drag\", \"dragControls\"],\n    focus: [\"whileFocus\"],\n    hover: [\"whileHover\", \"onHoverStart\", \"onHoverEnd\"],\n    tap: [\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"],\n    pan: [\"onPan\", \"onPanStart\", \"onPanSessionStart\", \"onPanEnd\"],\n    inView: [\"whileInView\", \"onViewportEnter\", \"onViewportLeave\"],\n    layout: [\"layout\", \"layoutId\"],\n};\nconst featureDefinitions = {};\nfor (const key in featureProps) {\n    featureDefinitions[key] = {\n        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),\n    };\n}\n\nexport { featureDefinitions };\n"],"names":["featureProps","featureDefinitions","key","props","name"],"mappings":"gFAAA,MAAMA,EAAe,CACjB,UAAW,CACP,UACA,WACA,aACA,WACA,OACA,cACA,aACA,WACH,EACD,KAAM,CAAC,MAAM,EACb,KAAM,CAAC,OAAQ,cAAc,EAC7B,MAAO,CAAC,YAAY,EACpB,MAAO,CAAC,aAAc,eAAgB,YAAY,EAClD,IAAK,CAAC,WAAY,QAAS,aAAc,aAAa,EACtD,IAAK,CAAC,QAAS,aAAc,oBAAqB,UAAU,EAC5D,OAAQ,CAAC,cAAe,kBAAmB,iBAAiB,EAC5D,OAAQ,CAAC,SAAU,UAAU,CACjC,EACMC,EAAqB,CAAG,EAC9B,UAAWC,KAAOF,EACdC,EAAmBC,CAAG,EAAI,CACtB,UAAYC,GAAUH,EAAaE,CAAG,EAAE,KAAME,GAAS,CAAC,CAACD,EAAMC,CAAI,CAAC,CAC5E","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra718.cjs","sources":["../node_modules/framer-motion/dist/es/motion/features/definitions.mjs"],"sourcesContent":["const featureProps = {\n    animation: [\n        \"animate\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"exit\",\n        \"whileInView\",\n        \"whileFocus\",\n        \"whileDrag\",\n    ],\n    exit: [\"exit\"],\n    drag: [\"drag\", \"dragControls\"],\n    focus: [\"whileFocus\"],\n    hover: [\"whileHover\", \"onHoverStart\", \"onHoverEnd\"],\n    tap: [\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"],\n    pan: [\"onPan\", \"onPanStart\", \"onPanSessionStart\", \"onPanEnd\"],\n    inView: [\"whileInView\", \"onViewportEnter\", \"onViewportLeave\"],\n    layout: [\"layout\", \"layoutId\"],\n};\nconst featureDefinitions = {};\nfor (const key in featureProps) {\n    featureDefinitions[key] = {\n        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),\n    };\n}\n\nexport { featureDefinitions };\n"],"names":["featureProps","featureDefinitions","key","props","name"],"mappings":"gFAAA,MAAMA,EAAe,CACjB,UAAW,CACP,UACA,WACA,aACA,WACA,OACA,cACA,aACA,WACH,EACD,KAAM,CAAC,MAAM,EACb,KAAM,CAAC,OAAQ,cAAc,EAC7B,MAAO,CAAC,YAAY,EACpB,MAAO,CAAC,aAAc,eAAgB,YAAY,EAClD,IAAK,CAAC,WAAY,QAAS,aAAc,aAAa,EACtD,IAAK,CAAC,QAAS,aAAc,oBAAqB,UAAU,EAC5D,OAAQ,CAAC,cAAe,kBAAmB,iBAAiB,EAC5D,OAAQ,CAAC,SAAU,UAAU,CACjC,EACMC,EAAqB,CAAA,EAC3B,UAAWC,KAAOF,EACdC,EAAmBC,CAAG,EAAI,CACtB,UAAYC,GAAUH,EAAaE,CAAG,EAAE,KAAME,GAAS,CAAC,CAACD,EAAMC,CAAI,CAAC,CACvE","x_google_ignoreList":[0]}

package/dist/lyra718.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra718.js","sources":["../node_modules/framer-motion/dist/es/motion/features/definitions.mjs"],"sourcesContent":["const featureProps = {\n    animation: [\n        \"animate\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"exit\",\n        \"whileInView\",\n        \"whileFocus\",\n        \"whileDrag\",\n    ],\n    exit: [\"exit\"],\n    drag: [\"drag\", \"dragControls\"],\n    focus: [\"whileFocus\"],\n    hover: [\"whileHover\", \"onHoverStart\", \"onHoverEnd\"],\n    tap: [\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"],\n    pan: [\"onPan\", \"onPanStart\", \"onPanSessionStart\", \"onPanEnd\"],\n    inView: [\"whileInView\", \"onViewportEnter\", \"onViewportLeave\"],\n    layout: [\"layout\", \"layoutId\"],\n};\nconst featureDefinitions = {};\nfor (const key in featureProps) {\n    featureDefinitions[key] = {\n        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),\n    };\n}\n\nexport { featureDefinitions };\n"],"names":["featureProps","featureDefinitions","key","props","name"],"mappings":"AAAA,MAAMA,IAAe;AAAA,EACjB,WAAW;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACH;AAAA,EACD,MAAM,CAAC,MAAM;AAAA,EACb,MAAM,CAAC,QAAQ,cAAc;AAAA,EAC7B,OAAO,CAAC,YAAY;AAAA,EACpB,OAAO,CAAC,cAAc,gBAAgB,YAAY;AAAA,EAClD,KAAK,CAAC,YAAY,SAAS,cAAc,aAAa;AAAA,EACtD,KAAK,CAAC,SAAS,cAAc,qBAAqB,UAAU;AAAA,EAC5D,QAAQ,CAAC,eAAe,mBAAmB,iBAAiB;AAAA,EAC5D,QAAQ,CAAC,UAAU,UAAU;AACjC,GACMC,IAAqB,CAAG;AAC9B,WAAWC,KAAOF;AACd,EAAAC,EAAmBC,CAAG,IAAI;AAAA,IACtB,WAAW,CAACC,MAAUH,EAAaE,CAAG,EAAE,KAAK,CAACE,MAAS,CAAC,CAACD,EAAMC,CAAI,CAAC;AAAA,EAC5E;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra718.js","sources":["../node_modules/framer-motion/dist/es/motion/features/definitions.mjs"],"sourcesContent":["const featureProps = {\n    animation: [\n        \"animate\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"exit\",\n        \"whileInView\",\n        \"whileFocus\",\n        \"whileDrag\",\n    ],\n    exit: [\"exit\"],\n    drag: [\"drag\", \"dragControls\"],\n    focus: [\"whileFocus\"],\n    hover: [\"whileHover\", \"onHoverStart\", \"onHoverEnd\"],\n    tap: [\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"],\n    pan: [\"onPan\", \"onPanStart\", \"onPanSessionStart\", \"onPanEnd\"],\n    inView: [\"whileInView\", \"onViewportEnter\", \"onViewportLeave\"],\n    layout: [\"layout\", \"layoutId\"],\n};\nconst featureDefinitions = {};\nfor (const key in featureProps) {\n    featureDefinitions[key] = {\n        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),\n    };\n}\n\nexport { featureDefinitions };\n"],"names":["featureProps","featureDefinitions","key","props","name"],"mappings":"AAAA,MAAMA,IAAe;AAAA,EACjB,WAAW;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACH;AAAA,EACD,MAAM,CAAC,MAAM;AAAA,EACb,MAAM,CAAC,QAAQ,cAAc;AAAA,EAC7B,OAAO,CAAC,YAAY;AAAA,EACpB,OAAO,CAAC,cAAc,gBAAgB,YAAY;AAAA,EAClD,KAAK,CAAC,YAAY,SAAS,cAAc,aAAa;AAAA,EACtD,KAAK,CAAC,SAAS,cAAc,qBAAqB,UAAU;AAAA,EAC5D,QAAQ,CAAC,eAAe,mBAAmB,iBAAiB;AAAA,EAC5D,QAAQ,CAAC,UAAU,UAAU;AACjC,GACMC,IAAqB,CAAA;AAC3B,WAAWC,KAAOF;AACd,EAAAC,EAAmBC,CAAG,IAAI;AAAA,IACtB,WAAW,CAACC,MAAUH,EAAaE,CAAG,EAAE,KAAK,CAACE,MAAS,CAAC,CAACD,EAAMC,CAAI,CAAC;AAAA,EACvE;","x_google_ignoreList":[0]}

package/dist/lyra72.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra72.cjs","sources":["../src/components/tabs/tab-link.tsx"],"sourcesContent":["import {\n  createContext,\n  CSSProperties,\n  ElementRef,\n  ForwardedRef,\n  ReactNode,\n  useContext,\n} from \"react\";\nimport { Link, LinkProps } from \"react-aria-components\";\n\nimport { VariantProps } from \"tailwind-variants\";\n\nimport { fixedForwardRef } from \"../../utils/helpers\";\n\nimport { tabStyles } from \"./tab.styles\";\n\nexport type TabLinkProps = LinkProps & Omit<VariantProps<typeof tabStyles>, \"orientation\">;\n\ntype TabLinkRef = ElementRef<typeof Link>;\n\nconst _TabLink = (\n  { className, isCurrent, isPending, isTransitioning, ...props }: TabLinkProps,\n  ref: ForwardedRef<TabLinkRef>,\n) => {\n  const { tab } = tabStyles();\n  const { orientation } = useTabLinkListContext();\n  return (\n    <Link\n      ref={ref}\n      className={(renderProps) =>\n        tab({\n          isPending,\n          isTransitioning,\n          ...renderProps,\n          isCurrent: isCurrent === undefined ? renderProps.isCurrent : isCurrent,\n          orientation,\n          className: typeof className === \"function\" ? className(renderProps) : className,\n        })\n      }\n      {...props}\n    ></Link>\n  );\n};\n\nexport const TabLink = fixedForwardRef(_TabLink);\n// @ts-ignore\nTabLink.displayName = \"TabLink\";\n\nexport type TabLinkListProps = Omit<VariantProps<typeof tabStyles>, \"isCurrent\"> & {\n  children: ReactNode;\n  className?: string;\n  style?: CSSProperties;\n};\n\nconst TabLinkListContext = createContext<TabLinkListProps | null>(null);\n\nconst _TabLinkList = (props: TabLinkListProps, ref: ForwardedRef<HTMLDivElement>) => {\n  const { children, className, orientation, style } = props;\n  const { list } = tabStyles();\n  return (\n    <div ref={ref} className={list({ orientation, className })} style={style}>\n      <TabLinkListContext.Provider value={props}>{children}</TabLinkListContext.Provider>\n    </div>\n  );\n};\n\nconst useTabLinkListContext = () => {\n  const context = useContext(TabLinkListContext);\n  if (!context) {\n    throw new Error(\"TabLinkListContext is undefined\");\n  }\n  return context;\n};\n\nexport const TabLinkList = fixedForwardRef(_TabLinkList);\n// @ts-ignore\nTabLinkList.displayName = \"TabLinkList\";\n"],"names":["_TabLink","className","isCurrent","isPending","isTransitioning","props","ref","tab","tabStyles","orientation","useTabLinkListContext","jsx","Link","renderProps","TabLink","fixedForwardRef","TabLinkListContext","createContext","_TabLinkList","children","style","list","context","useContext","TabLinkList"],"mappings":"iNAoBMA,EAAW,CACf,CAAE,UAAAC,EAAW,UAAAC,EAAW,UAAAC,EAAW,gBAAAC,EAAiB,GAAGC,CAAM,EAC7DC,IACG,CACG,KAAA,CAAE,IAAAC,GAAQC,EAAAA,YACV,CAAE,YAAAC,GAAgBC,IAEtB,OAAAC,EAAA,kBAAA,IAACC,EAAA,KAAA,CACC,IAAAN,EACA,UAAYO,GACVN,EAAI,CACF,UAAAJ,EACA,gBAAAC,EACA,GAAGS,EACH,UAAWX,IAAc,OAAYW,EAAY,UAAYX,EAC7D,YAAAO,EACA,UAAW,OAAOR,GAAc,WAAaA,EAAUY,CAAW,EAAIZ,CAAA,CACvE,EAEF,GAAGI,CAAA,CAAA,CAGV,EAEaS,EAAUC,kBAAgBf,CAAQ,EAE/Cc,EAAQ,YAAc,UAQtB,MAAME,EAAqBC,EAAAA,cAAuC,IAAI,EAEhEC,EAAe,CAACb,EAAyBC,IAAsC,CACnF,KAAM,CAAE,SAAAa,EAAU,UAAAlB,EAAW,YAAAQ,EAAa,MAAAW,GAAUf,EAC9C,CAAE,KAAAgB,GAASb,EAAAA,YACjB,+BACG,MAAI,CAAA,IAAAF,EAAU,UAAWe,EAAK,CAAE,YAAAZ,EAAa,UAAAR,EAAW,EAAG,MAAAmB,EAC1D,iCAACJ,EAAmB,SAAnB,CAA4B,MAAOX,EAAQ,SAAAc,EAAS,CACvD,CAAA,CAEJ,EAEMT,EAAwB,IAAM,CAC5B,MAAAY,EAAUC,aAAWP,CAAkB,EAC7C,GAAI,CAACM,EACG,MAAA,IAAI,MAAM,iCAAiC,EAE5C,OAAAA,CACT,EAEaE,EAAcT,kBAAgBG,CAAY,EAEvDM,EAAY,YAAc"}
+{"version":3,"file":"lyra72.cjs","sources":["../src/components/tabs/tab-link.tsx"],"sourcesContent":["import {\n  createContext,\n  CSSProperties,\n  ElementRef,\n  ForwardedRef,\n  ReactNode,\n  useContext,\n} from \"react\";\nimport { Link, LinkProps } from \"react-aria-components\";\n\nimport { VariantProps } from \"tailwind-variants\";\n\nimport { fixedForwardRef } from \"../../utils/helpers\";\n\nimport { tabStyles } from \"./tab.styles\";\n\nexport type TabLinkProps = LinkProps & Omit<VariantProps<typeof tabStyles>, \"orientation\">;\n\ntype TabLinkRef = ElementRef<typeof Link>;\n\nconst _TabLink = (\n  { className, isCurrent, isPending, isTransitioning, ...props }: TabLinkProps,\n  ref: ForwardedRef<TabLinkRef>,\n) => {\n  const { tab } = tabStyles();\n  const { orientation } = useTabLinkListContext();\n  return (\n    <Link\n      ref={ref}\n      className={(renderProps) =>\n        tab({\n          isPending,\n          isTransitioning,\n          ...renderProps,\n          isCurrent: isCurrent === undefined ? renderProps.isCurrent : isCurrent,\n          orientation,\n          className: typeof className === \"function\" ? className(renderProps) : className,\n        })\n      }\n      {...props}\n    ></Link>\n  );\n};\n\nexport const TabLink = fixedForwardRef(_TabLink);\n// @ts-ignore\nTabLink.displayName = \"TabLink\";\n\nexport type TabLinkListProps = Omit<VariantProps<typeof tabStyles>, \"isCurrent\"> & {\n  children: ReactNode;\n  className?: string;\n  style?: CSSProperties;\n};\n\nconst TabLinkListContext = createContext<TabLinkListProps | null>(null);\n\nconst _TabLinkList = (props: TabLinkListProps, ref: ForwardedRef<HTMLDivElement>) => {\n  const { children, className, orientation, style } = props;\n  const { list } = tabStyles();\n  return (\n    <div ref={ref} className={list({ orientation, className })} style={style}>\n      <TabLinkListContext.Provider value={props}>{children}</TabLinkListContext.Provider>\n    </div>\n  );\n};\n\nconst useTabLinkListContext = () => {\n  const context = useContext(TabLinkListContext);\n  if (!context) {\n    throw new Error(\"TabLinkListContext is undefined\");\n  }\n  return context;\n};\n\nexport const TabLinkList = fixedForwardRef(_TabLinkList);\n// @ts-ignore\nTabLinkList.displayName = \"TabLinkList\";\n"],"names":["_TabLink","className","isCurrent","isPending","isTransitioning","props","ref","tab","tabStyles","orientation","useTabLinkListContext","jsx","Link","renderProps","TabLink","fixedForwardRef","TabLinkListContext","createContext","_TabLinkList","children","style","list","context","useContext","TabLinkList"],"mappings":"iNAoBMA,EAAW,CACf,CAAE,UAAAC,EAAW,UAAAC,EAAW,UAAAC,EAAW,gBAAAC,EAAiB,GAAGC,CAAM,EAC7DC,IACG,CACG,KAAA,CAAE,IAAAC,CAAI,EAAIC,YAAU,EACpB,CAAE,YAAAC,CAAY,EAAIC,EAAsB,EAE5C,OAAAC,EAAA,kBAAA,IAACC,EAAA,KAAA,CACC,IAAAN,EACA,UAAYO,GACVN,EAAI,CACF,UAAAJ,EACA,gBAAAC,EACA,GAAGS,EACH,UAAWX,IAAc,OAAYW,EAAY,UAAYX,EAC7D,YAAAO,EACA,UAAW,OAAOR,GAAc,WAAaA,EAAUY,CAAW,EAAIZ,CAAA,CACvE,EAEF,GAAGI,CAAA,CACL,CAEL,EAEaS,EAAUC,kBAAgBf,CAAQ,EAE/Cc,EAAQ,YAAc,UAQtB,MAAME,EAAqBC,gBAAuC,IAAI,EAEhEC,EAAe,CAACb,EAAyBC,IAAsC,CACnF,KAAM,CAAE,SAAAa,EAAU,UAAAlB,EAAW,YAAAQ,EAAa,MAAAW,CAAU,EAAAf,EAC9C,CAAE,KAAAgB,CAAK,EAAIb,YAAU,EAC3B,+BACG,MAAI,CAAA,IAAAF,EAAU,UAAWe,EAAK,CAAE,YAAAZ,EAAa,UAAAR,EAAW,EAAG,MAAAmB,EAC1D,iCAACJ,EAAmB,SAAnB,CAA4B,MAAOX,EAAQ,SAAAc,CAAS,CAAA,EACvD,CAEJ,EAEMT,EAAwB,IAAM,CAC5B,MAAAY,EAAUC,aAAWP,CAAkB,EAC7C,GAAI,CAACM,EACG,MAAA,IAAI,MAAM,iCAAiC,EAE5C,OAAAA,CACT,EAEaE,EAAcT,kBAAgBG,CAAY,EAEvDM,EAAY,YAAc"}

package/dist/lyra72.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra72.js","sources":["../src/components/tabs/tab-link.tsx"],"sourcesContent":["import {\n  createContext,\n  CSSProperties,\n  ElementRef,\n  ForwardedRef,\n  ReactNode,\n  useContext,\n} from \"react\";\nimport { Link, LinkProps } from \"react-aria-components\";\n\nimport { VariantProps } from \"tailwind-variants\";\n\nimport { fixedForwardRef } from \"../../utils/helpers\";\n\nimport { tabStyles } from \"./tab.styles\";\n\nexport type TabLinkProps = LinkProps & Omit<VariantProps<typeof tabStyles>, \"orientation\">;\n\ntype TabLinkRef = ElementRef<typeof Link>;\n\nconst _TabLink = (\n  { className, isCurrent, isPending, isTransitioning, ...props }: TabLinkProps,\n  ref: ForwardedRef<TabLinkRef>,\n) => {\n  const { tab } = tabStyles();\n  const { orientation } = useTabLinkListContext();\n  return (\n    <Link\n      ref={ref}\n      className={(renderProps) =>\n        tab({\n          isPending,\n          isTransitioning,\n          ...renderProps,\n          isCurrent: isCurrent === undefined ? renderProps.isCurrent : isCurrent,\n          orientation,\n          className: typeof className === \"function\" ? className(renderProps) : className,\n        })\n      }\n      {...props}\n    ></Link>\n  );\n};\n\nexport const TabLink = fixedForwardRef(_TabLink);\n// @ts-ignore\nTabLink.displayName = \"TabLink\";\n\nexport type TabLinkListProps = Omit<VariantProps<typeof tabStyles>, \"isCurrent\"> & {\n  children: ReactNode;\n  className?: string;\n  style?: CSSProperties;\n};\n\nconst TabLinkListContext = createContext<TabLinkListProps | null>(null);\n\nconst _TabLinkList = (props: TabLinkListProps, ref: ForwardedRef<HTMLDivElement>) => {\n  const { children, className, orientation, style } = props;\n  const { list } = tabStyles();\n  return (\n    <div ref={ref} className={list({ orientation, className })} style={style}>\n      <TabLinkListContext.Provider value={props}>{children}</TabLinkListContext.Provider>\n    </div>\n  );\n};\n\nconst useTabLinkListContext = () => {\n  const context = useContext(TabLinkListContext);\n  if (!context) {\n    throw new Error(\"TabLinkListContext is undefined\");\n  }\n  return context;\n};\n\nexport const TabLinkList = fixedForwardRef(_TabLinkList);\n// @ts-ignore\nTabLinkList.displayName = \"TabLinkList\";\n"],"names":["_TabLink","className","isCurrent","isPending","isTransitioning","props","ref","tab","tabStyles","orientation","useTabLinkListContext","jsx","Link","renderProps","TabLink","fixedForwardRef","TabLinkListContext","createContext","_TabLinkList","children","style","list","context","useContext","TabLinkList"],"mappings":";;;;;AAoBA,MAAMA,IAAW,CACf,EAAE,WAAAC,GAAW,WAAAC,GAAW,WAAAC,GAAW,iBAAAC,GAAiB,GAAGC,EAAM,GAC7DC,MACG;AACG,QAAA,EAAE,KAAAC,MAAQC,KACV,EAAE,aAAAC,MAAgBC;AAEtB,SAAAC,gBAAAA,EAAA;AAAA,IAACC;AAAAA,IAAA;AAAA,MACC,KAAAN;AAAA,MACA,WAAW,CAACO,MACVN,EAAI;AAAA,QACF,WAAAJ;AAAA,QACA,iBAAAC;AAAA,QACA,GAAGS;AAAA,QACH,WAAWX,MAAc,SAAYW,EAAY,YAAYX;AAAA,QAC7D,aAAAO;AAAA,QACA,WAAW,OAAOR,KAAc,aAAaA,EAAUY,CAAW,IAAIZ;AAAA,MAAA,CACvE;AAAA,MAEF,GAAGI;AAAA,IAAA;AAAA,EAAA;AAGV,GAEaS,IAAUC,EAAgBf,CAAQ;AAE/Cc,EAAQ,cAAc;AAQtB,MAAME,IAAqBC,EAAuC,IAAI,GAEhEC,IAAe,CAACb,GAAyBC,MAAsC;AACnF,QAAM,EAAE,UAAAa,GAAU,WAAAlB,GAAW,aAAAQ,GAAa,OAAAW,MAAUf,GAC9C,EAAE,MAAAgB,MAASb;AACjB,+BACG,OAAI,EAAA,KAAAF,GAAU,WAAWe,EAAK,EAAE,aAAAZ,GAAa,WAAAR,GAAW,GAAG,OAAAmB,GAC1D,gCAACJ,EAAmB,UAAnB,EAA4B,OAAOX,GAAQ,UAAAc,GAAS,EACvD,CAAA;AAEJ,GAEMT,IAAwB,MAAM;AAC5B,QAAAY,IAAUC,EAAWP,CAAkB;AAC7C,MAAI,CAACM;AACG,UAAA,IAAI,MAAM,iCAAiC;AAE5C,SAAAA;AACT,GAEaE,IAAcT,EAAgBG,CAAY;AAEvDM,EAAY,cAAc;"}
+{"version":3,"file":"lyra72.js","sources":["../src/components/tabs/tab-link.tsx"],"sourcesContent":["import {\n  createContext,\n  CSSProperties,\n  ElementRef,\n  ForwardedRef,\n  ReactNode,\n  useContext,\n} from \"react\";\nimport { Link, LinkProps } from \"react-aria-components\";\n\nimport { VariantProps } from \"tailwind-variants\";\n\nimport { fixedForwardRef } from \"../../utils/helpers\";\n\nimport { tabStyles } from \"./tab.styles\";\n\nexport type TabLinkProps = LinkProps & Omit<VariantProps<typeof tabStyles>, \"orientation\">;\n\ntype TabLinkRef = ElementRef<typeof Link>;\n\nconst _TabLink = (\n  { className, isCurrent, isPending, isTransitioning, ...props }: TabLinkProps,\n  ref: ForwardedRef<TabLinkRef>,\n) => {\n  const { tab } = tabStyles();\n  const { orientation } = useTabLinkListContext();\n  return (\n    <Link\n      ref={ref}\n      className={(renderProps) =>\n        tab({\n          isPending,\n          isTransitioning,\n          ...renderProps,\n          isCurrent: isCurrent === undefined ? renderProps.isCurrent : isCurrent,\n          orientation,\n          className: typeof className === \"function\" ? className(renderProps) : className,\n        })\n      }\n      {...props}\n    ></Link>\n  );\n};\n\nexport const TabLink = fixedForwardRef(_TabLink);\n// @ts-ignore\nTabLink.displayName = \"TabLink\";\n\nexport type TabLinkListProps = Omit<VariantProps<typeof tabStyles>, \"isCurrent\"> & {\n  children: ReactNode;\n  className?: string;\n  style?: CSSProperties;\n};\n\nconst TabLinkListContext = createContext<TabLinkListProps | null>(null);\n\nconst _TabLinkList = (props: TabLinkListProps, ref: ForwardedRef<HTMLDivElement>) => {\n  const { children, className, orientation, style } = props;\n  const { list } = tabStyles();\n  return (\n    <div ref={ref} className={list({ orientation, className })} style={style}>\n      <TabLinkListContext.Provider value={props}>{children}</TabLinkListContext.Provider>\n    </div>\n  );\n};\n\nconst useTabLinkListContext = () => {\n  const context = useContext(TabLinkListContext);\n  if (!context) {\n    throw new Error(\"TabLinkListContext is undefined\");\n  }\n  return context;\n};\n\nexport const TabLinkList = fixedForwardRef(_TabLinkList);\n// @ts-ignore\nTabLinkList.displayName = \"TabLinkList\";\n"],"names":["_TabLink","className","isCurrent","isPending","isTransitioning","props","ref","tab","tabStyles","orientation","useTabLinkListContext","jsx","Link","renderProps","TabLink","fixedForwardRef","TabLinkListContext","createContext","_TabLinkList","children","style","list","context","useContext","TabLinkList"],"mappings":";;;;;AAoBA,MAAMA,IAAW,CACf,EAAE,WAAAC,GAAW,WAAAC,GAAW,WAAAC,GAAW,iBAAAC,GAAiB,GAAGC,EAAM,GAC7DC,MACG;AACG,QAAA,EAAE,KAAAC,EAAI,IAAIC,EAAU,GACpB,EAAE,aAAAC,EAAY,IAAIC,EAAsB;AAE5C,SAAAC,gBAAAA,EAAA;AAAA,IAACC;AAAAA,IAAA;AAAA,MACC,KAAAN;AAAA,MACA,WAAW,CAACO,MACVN,EAAI;AAAA,QACF,WAAAJ;AAAA,QACA,iBAAAC;AAAA,QACA,GAAGS;AAAA,QACH,WAAWX,MAAc,SAAYW,EAAY,YAAYX;AAAA,QAC7D,aAAAO;AAAA,QACA,WAAW,OAAOR,KAAc,aAAaA,EAAUY,CAAW,IAAIZ;AAAA,MAAA,CACvE;AAAA,MAEF,GAAGI;AAAA,IAAA;AAAA,EACL;AAEL,GAEaS,IAAUC,EAAgBf,CAAQ;AAE/Cc,EAAQ,cAAc;AAQtB,MAAME,IAAqBC,EAAuC,IAAI,GAEhEC,IAAe,CAACb,GAAyBC,MAAsC;AACnF,QAAM,EAAE,UAAAa,GAAU,WAAAlB,GAAW,aAAAQ,GAAa,OAAAW,EAAU,IAAAf,GAC9C,EAAE,MAAAgB,EAAK,IAAIb,EAAU;AAC3B,+BACG,OAAI,EAAA,KAAAF,GAAU,WAAWe,EAAK,EAAE,aAAAZ,GAAa,WAAAR,GAAW,GAAG,OAAAmB,GAC1D,gCAACJ,EAAmB,UAAnB,EAA4B,OAAOX,GAAQ,UAAAc,EAAS,CAAA,GACvD;AAEJ,GAEMT,IAAwB,MAAM;AAC5B,QAAAY,IAAUC,EAAWP,CAAkB;AAC7C,MAAI,CAACM;AACG,UAAA,IAAI,MAAM,iCAAiC;AAE5C,SAAAA;AACT,GAEaE,IAAcT,EAAgBG,CAAY;AAEvDM,EAAY,cAAc;"}

package/dist/lyra722.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra722.cjs","sources":["../node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs"],"sourcesContent":["const scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n"],"names":["scaleCorrectors","addScaleCorrector","correctors"],"mappings":"gFAAK,MAACA,EAAkB,CAAG,EAC3B,SAASC,EAAkBC,EAAY,CACnC,OAAO,OAAOF,EAAiBE,CAAU,CAC7C","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra722.cjs","sources":["../node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs"],"sourcesContent":["const scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n"],"names":["scaleCorrectors","addScaleCorrector","correctors"],"mappings":"gFAAK,MAACA,EAAkB,CAAA,EACxB,SAASC,EAAkBC,EAAY,CACnC,OAAO,OAAOF,EAAiBE,CAAU,CAC7C","x_google_ignoreList":[0]}

package/dist/lyra722.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra722.js","sources":["../node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs"],"sourcesContent":["const scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n"],"names":["scaleCorrectors","addScaleCorrector","correctors"],"mappings":"AAAK,MAACA,IAAkB,CAAG;AAC3B,SAASC,EAAkBC,GAAY;AACnC,SAAO,OAAOF,GAAiBE,CAAU;AAC7C;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra722.js","sources":["../node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs"],"sourcesContent":["const scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n"],"names":["scaleCorrectors","addScaleCorrector","correctors"],"mappings":"AAAK,MAACA,IAAkB,CAAA;AACxB,SAASC,EAAkBC,GAAY;AACnC,SAAO,OAAOF,GAAiBE,CAAU;AAC7C;","x_google_ignoreList":[0]}

package/dist/lyra723.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra723.cjs","sources":["../node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs"],"sourcesContent":["import { transformPropOrder } from './transform.mjs';\n\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(transform, { enableHardwareAcceleration = true, allowTransformNone = true, }, transformIsDefault, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        if (transform[key] !== undefined) {\n            const transformName = translateAlias[key] || key;\n            transformString += `${transformName}(${transform[key]}) `;\n        }\n    }\n    if (enableHardwareAcceleration && !transform.z) {\n        transformString += \"translateZ(0)\";\n    }\n    transformString = transformString.trim();\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n\nexport { buildTransform };\n"],"names":["translateAlias","numTransforms","transformPropOrder","buildTransform","transform","enableHardwareAcceleration","allowTransformNone","transformIsDefault","transformTemplate","transformString","i","key","transformName"],"mappings":"iHAEMA,EAAiB,CACnB,EAAG,aACH,EAAG,aACH,EAAG,aACH,qBAAsB,aAC1B,EACMC,EAAgBC,EAAkB,mBAAC,OAOzC,SAASC,EAAeC,EAAW,CAAE,2BAAAC,EAA6B,GAAM,mBAAAC,EAAqB,EAAI,EAAKC,EAAoBC,EAAmB,CAEzI,IAAIC,EAAkB,GAKtB,QAASC,EAAI,EAAGA,EAAIT,EAAeS,IAAK,CACpC,MAAMC,EAAMT,qBAAmBQ,CAAC,EAChC,GAAIN,EAAUO,CAAG,IAAM,OAAW,CAC9B,MAAMC,EAAgBZ,EAAeW,CAAG,GAAKA,EAC7CF,GAAmB,GAAGG,CAAa,IAAIR,EAAUO,CAAG,CAAC,IACxD,CACJ,CACD,OAAIN,GAA8B,CAACD,EAAU,IACzCK,GAAmB,iBAEvBA,EAAkBA,EAAgB,OAG9BD,EACAC,EAAkBD,EAAkBJ,EAAWG,EAAqB,GAAKE,CAAe,EAEnFH,GAAsBC,IAC3BE,EAAkB,QAEfA,CACX","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra723.cjs","sources":["../node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs"],"sourcesContent":["import { transformPropOrder } from './transform.mjs';\n\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(transform, { enableHardwareAcceleration = true, allowTransformNone = true, }, transformIsDefault, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        if (transform[key] !== undefined) {\n            const transformName = translateAlias[key] || key;\n            transformString += `${transformName}(${transform[key]}) `;\n        }\n    }\n    if (enableHardwareAcceleration && !transform.z) {\n        transformString += \"translateZ(0)\";\n    }\n    transformString = transformString.trim();\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n\nexport { buildTransform };\n"],"names":["translateAlias","numTransforms","transformPropOrder","buildTransform","transform","enableHardwareAcceleration","allowTransformNone","transformIsDefault","transformTemplate","transformString","i","key","transformName"],"mappings":"iHAEMA,EAAiB,CACnB,EAAG,aACH,EAAG,aACH,EAAG,aACH,qBAAsB,aAC1B,EACMC,EAAgBC,EAAkB,mBAAC,OAOzC,SAASC,EAAeC,EAAW,CAAE,2BAAAC,EAA6B,GAAM,mBAAAC,EAAqB,EAAI,EAAKC,EAAoBC,EAAmB,CAEzI,IAAIC,EAAkB,GAKtB,QAASC,EAAI,EAAGA,EAAIT,EAAeS,IAAK,CACpC,MAAMC,EAAMT,EAAkB,mBAACQ,CAAC,EAChC,GAAIN,EAAUO,CAAG,IAAM,OAAW,CAC9B,MAAMC,EAAgBZ,EAAeW,CAAG,GAAKA,EAC7CF,GAAmB,GAAGG,CAAa,IAAIR,EAAUO,CAAG,CAAC,IACjE,CACA,CACI,OAAIN,GAA8B,CAACD,EAAU,IACzCK,GAAmB,iBAEvBA,EAAkBA,EAAgB,KAAM,EAGpCD,EACAC,EAAkBD,EAAkBJ,EAAWG,EAAqB,GAAKE,CAAe,EAEnFH,GAAsBC,IAC3BE,EAAkB,QAEfA,CACX","x_google_ignoreList":[0]}

package/dist/lyra723.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra723.js","sources":["../node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs"],"sourcesContent":["import { transformPropOrder } from './transform.mjs';\n\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(transform, { enableHardwareAcceleration = true, allowTransformNone = true, }, transformIsDefault, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        if (transform[key] !== undefined) {\n            const transformName = translateAlias[key] || key;\n            transformString += `${transformName}(${transform[key]}) `;\n        }\n    }\n    if (enableHardwareAcceleration && !transform.z) {\n        transformString += \"translateZ(0)\";\n    }\n    transformString = transformString.trim();\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n\nexport { buildTransform };\n"],"names":["translateAlias","numTransforms","transformPropOrder","buildTransform","transform","enableHardwareAcceleration","allowTransformNone","transformIsDefault","transformTemplate","transformString","i","key","transformName"],"mappings":";AAEA,MAAMA,IAAiB;AAAA,EACnB,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,sBAAsB;AAC1B,GACMC,IAAgBC,EAAmB;AAOzC,SAASC,EAAeC,GAAW,EAAE,4BAAAC,IAA6B,IAAM,oBAAAC,IAAqB,GAAI,GAAKC,GAAoBC,GAAmB;AAEzI,MAAIC,IAAkB;AAKtB,WAASC,IAAI,GAAGA,IAAIT,GAAeS,KAAK;AACpC,UAAMC,IAAMT,EAAmBQ,CAAC;AAChC,QAAIN,EAAUO,CAAG,MAAM,QAAW;AAC9B,YAAMC,IAAgBZ,EAAeW,CAAG,KAAKA;AAC7C,MAAAF,KAAmB,GAAGG,CAAa,IAAIR,EAAUO,CAAG,CAAC;AAAA,IACxD;AAAA,EACJ;AACD,SAAIN,KAA8B,CAACD,EAAU,MACzCK,KAAmB,kBAEvBA,IAAkBA,EAAgB,QAG9BD,IACAC,IAAkBD,EAAkBJ,GAAWG,IAAqB,KAAKE,CAAe,IAEnFH,KAAsBC,MAC3BE,IAAkB,SAEfA;AACX;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra723.js","sources":["../node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs"],"sourcesContent":["import { transformPropOrder } from './transform.mjs';\n\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(transform, { enableHardwareAcceleration = true, allowTransformNone = true, }, transformIsDefault, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        if (transform[key] !== undefined) {\n            const transformName = translateAlias[key] || key;\n            transformString += `${transformName}(${transform[key]}) `;\n        }\n    }\n    if (enableHardwareAcceleration && !transform.z) {\n        transformString += \"translateZ(0)\";\n    }\n    transformString = transformString.trim();\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n\nexport { buildTransform };\n"],"names":["translateAlias","numTransforms","transformPropOrder","buildTransform","transform","enableHardwareAcceleration","allowTransformNone","transformIsDefault","transformTemplate","transformString","i","key","transformName"],"mappings":";AAEA,MAAMA,IAAiB;AAAA,EACnB,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,sBAAsB;AAC1B,GACMC,IAAgBC,EAAmB;AAOzC,SAASC,EAAeC,GAAW,EAAE,4BAAAC,IAA6B,IAAM,oBAAAC,IAAqB,GAAI,GAAKC,GAAoBC,GAAmB;AAEzI,MAAIC,IAAkB;AAKtB,WAASC,IAAI,GAAGA,IAAIT,GAAeS,KAAK;AACpC,UAAMC,IAAMT,EAAmBQ,CAAC;AAChC,QAAIN,EAAUO,CAAG,MAAM,QAAW;AAC9B,YAAMC,IAAgBZ,EAAeW,CAAG,KAAKA;AAC7C,MAAAF,KAAmB,GAAGG,CAAa,IAAIR,EAAUO,CAAG,CAAC;AAAA,IACjE;AAAA,EACA;AACI,SAAIN,KAA8B,CAACD,EAAU,MACzCK,KAAmB,kBAEvBA,IAAkBA,EAAgB,KAAM,GAGpCD,IACAC,IAAkBD,EAAkBJ,GAAWG,IAAqB,KAAKE,CAAe,IAEnFH,KAAsBC,MAC3BE,IAAkB,SAEfA;AACX;","x_google_ignoreList":[0]}

package/dist/lyra724.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra724.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';\nimport { invariant } from '../../../utils/errors.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     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        if (process.env.NODE_ENV !== \"production\") {\n            invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n        }\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 = Math.min(currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        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","invariant","interpolate","generator","mirroredGenerator","playState","holdTime","startTime","cancelTime","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","currentTime","tick","timestamp","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","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":"lyra724.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';\nimport { invariant } from '../../../utils/errors.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     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        if (process.env.NODE_ENV !== \"production\") {\n            invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n        }\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 = Math.min(currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        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","invariant","interpolate","generator","mirroredGenerator","playState","holdTime","startTime","cancelTime","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","currentTime","tick","timestamp","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","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]}

package/dist/lyra724.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra724.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';\nimport { invariant } from '../../../utils/errors.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     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        if (process.env.NODE_ENV !== \"production\") {\n            invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n        }\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 = Math.min(currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        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","invariant","interpolate","generator","mirroredGenerator","playState","holdTime","startTime","cancelTime","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","currentTime","tick","timestamp","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","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":"lyra724.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';\nimport { invariant } from '../../../utils/errors.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     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        if (process.env.NODE_ENV !== \"production\") {\n            invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n        }\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 = Math.min(currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        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","invariant","interpolate","generator","mirroredGenerator","playState","holdTime","startTime","cancelTime","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","currentTime","tick","timestamp","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","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]}

package/dist/lyra725.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra725.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":"lyra725.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,EAAAA,cAAcF,CAAI,EACpCA,EAAK,IAAIG,EAA0B,0BAAA,EACnCA,EAAAA,2BAA2BH,CAAI,EAK/BI,EAAQ,CACV,KAAM,GACN,MAAON,EAAe,CAAC,CAC1B,EAIKO,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,EAEd,CACL","x_google_ignoreList":[0]}

package/dist/lyra725.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra725.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":"lyra725.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,EAC1B,GAIKO,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,EAEd;AACL;","x_google_ignoreList":[0]}

package/dist/lyra726.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra726.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            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, 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 ? 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","duration","velocity","isResolvedFromDuration","millisecondsToSeconds","initialVelocity","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":"lyra726.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            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, 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 ? 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","duration","velocity","isResolvedFromDuration","millisecondsToSeconds","initialVelocity","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]}