@new-black/lyra 0.1.7 → 0.1.8

package/dist/lyra310.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra310.js","sources":["../node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs"],"sourcesContent":["// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n"],"names":["hueToRgb","p","q","t","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue"],"mappings":"AACA,SAASA,EAASC,GAAGC,GAAGC,GAAG;AAKvB,SAJIA,IAAI,MACJA,KAAK,IACLA,IAAI,MACJA,KAAK,IACLA,IAAI,IAAI,IACDF,KAAKC,IAAID,KAAK,IAAIE,IACzBA,IAAI,IAAI,IACDD,IACPC,IAAI,IAAI,IACDF,KAAKC,IAAID,MAAM,IAAI,IAAIE,KAAK,IAChCF;AACX;AACA,SAASG,EAAW,EAAE,KAAAC,GAAK,YAAAC,GAAY,WAAAC,GAAW,OAAAC,EAAK,GAAI;AACvD,EAAAH,KAAO,KACPC,KAAc,KACdC,KAAa;AACb,MAAIE,IAAM,GACNC,IAAQ,GACRC,IAAO;AACX,MAAI,CAACL;AACD,IAAAG,IAAMC,IAAQC,IAAOJ;AAAA,OAEpB;AACD,UAAML,IAAIK,IAAY,MAChBA,KAAa,IAAID,KACjBC,IAAYD,IAAaC,IAAYD,GACrCL,IAAI,IAAIM,IAAYL;AAC1B,IAAAO,IAAMT,EAASC,GAAGC,GAAGG,IAAM,IAAI,CAAC,GAChCK,IAAQV,EAASC,GAAGC,GAAGG,CAAG,GAC1BM,IAAOX,EAASC,GAAGC,GAAGG,IAAM,IAAI,CAAC;AAAA,EACpC;AACD,SAAO;AAAA,IACH,KAAK,KAAK,MAAMI,IAAM,GAAG;AAAA,IACzB,OAAO,KAAK,MAAMC,IAAQ,GAAG;AAAA,IAC7B,MAAM,KAAK,MAAMC,IAAO,GAAG;AAAA,IAC3B,OAAAH;AAAA,EACR;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra310.js","sources":["../node_modules/framer-motion/dist/es/frameloop/render-step.mjs"],"sourcesContent":["function createRenderStep(runNextFrame) {\n    /**\n     * We create and reuse two arrays, one to queue jobs for the current frame\n     * and one for the next. We reuse to avoid triggering GC after x frames.\n     */\n    let toRun = [];\n    let toRunNextFrame = [];\n    /**\n     *\n     */\n    let numToRun = 0;\n    /**\n     * Track whether we're currently processing jobs in this step. This way\n     * we can decide whether to schedule new jobs for this frame or next.\n     */\n    let isProcessing = false;\n    let flushNextFrame = false;\n    /**\n     * A set of processes which were marked keepAlive when scheduled.\n     */\n    const toKeepAlive = new WeakSet();\n    const step = {\n        /**\n         * Schedule a process to run on the next frame.\n         */\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            // If the buffer doesn't already contain this callback, add it\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                // If we're adding it to the currently running buffer, update its measured size\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        /**\n         * Cancel the provided callback from running on the next frame.\n         */\n        cancel: (callback) => {\n            const index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        /**\n         * Execute all schedule callbacks.\n         */\n        process: (frameData) => {\n            /**\n             * If we're already processing we've probably been triggered by a flushSync\n             * inside an existing process. Instead of executing, mark flushNextFrame\n             * as true and ensure we flush the following frame at the end of this one.\n             */\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [toRun, toRunNextFrame] = [toRunNextFrame, toRun];\n            // Clear the next frame list\n            toRunNextFrame.length = 0;\n            // Execute this frame\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n"],"names":["createRenderStep","runNextFrame","toRun","toRunNextFrame","numToRun","isProcessing","flushNextFrame","toKeepAlive","step","callback","keepAlive","immediate","addToCurrentFrame","buffer","index","frameData","i"],"mappings":"AAAA,SAASA,EAAiBC,GAAc;AAKpC,MAAIC,IAAQ,CAAA,GACRC,IAAiB,CAAA,GAIjBC,IAAW,GAKXC,IAAe,IACfC,IAAiB;AAIrB,QAAMC,IAAc,oBAAI,WAClBC,IAAO;AAAA;AAAA;AAAA;AAAA,IAIT,UAAU,CAACC,GAAUC,IAAY,IAAOC,IAAY,OAAU;AAC1D,YAAMC,IAAoBD,KAAaN,GACjCQ,IAASD,IAAoBV,IAAQC;AAC3C,aAAIO,KACAH,EAAY,IAAIE,CAAQ,GAExBI,EAAO,QAAQJ,CAAQ,MAAM,OAC7BI,EAAO,KAAKJ,CAAQ,GAEhBG,KAAqBP,MACrBD,IAAWF,EAAM,UAElBO;AAAA,IACV;AAAA;AAAA;AAAA;AAAA,IAID,QAAQ,CAACA,MAAa;AAClB,YAAMK,IAAQX,EAAe,QAAQM,CAAQ;AAC7C,MAAIK,MAAU,MACVX,EAAe,OAAOW,GAAO,CAAC,GAClCP,EAAY,OAAOE,CAAQ;AAAA,IAC9B;AAAA;AAAA;AAAA;AAAA,IAID,SAAS,CAACM,MAAc;AAMpB,UAAIV,GAAc;AACd,QAAAC,IAAiB;AACjB;AAAA,MACH;AAOD,UANAD,IAAe,IACf,CAACH,GAAOC,CAAc,IAAI,CAACA,GAAgBD,CAAK,GAEhDC,EAAe,SAAS,GAExBC,IAAWF,EAAM,QACbE;AACA,iBAASY,IAAI,GAAGA,IAAIZ,GAAUY,KAAK;AAC/B,gBAAMP,IAAWP,EAAMc,CAAC;AACxB,UAAAP,EAASM,CAAS,GACdR,EAAY,IAAIE,CAAQ,MACxBD,EAAK,SAASC,CAAQ,GACtBR;QAEP;AAEL,MAAAI,IAAe,IACXC,MACAA,IAAiB,IACjBE,EAAK,QAAQO,CAAS;AAAA,IAE7B;AAAA,EACT;AACI,SAAOP;AACX;","x_google_ignoreList":[0]}

package/dist/lyra311.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const _=require("./lyra265.cjs"),k=require("./lyra294.cjs"),D=require("./lyra363.cjs"),j=require("./lyra203.cjs"),z=require("./lyra176.cjs"),R=require("./lyra208.cjs"),H=require("./lyra175.cjs"),G=[...R.variantPriorityOrder].reverse(),J=R.variantPriorityOrder.length;function N(e){return s=>Promise.all(s.map(({animation:c,options:y})=>H.animateVisualElement(e,c,y)))}function Q(e){let s=N(e);const c=U();let y=!0;const M=(i,u)=>{const l=z.resolveVariant(e,u);if(l){const{transition:p,transitionEnd:f,...a}=l;i={...i,...a,...f}}return i};function x(i){s=i(e)}function T(i,u){const l=e.getProps(),p=e.getVariantContext(!0)||{},f=[],a=new Set;let d={},S=1/0;for(let m=0;m<J;m++){const r=G[m],t=c[r],o=l[r]!==void 0?l[r]:p[r],V=j.isVariantLabel(o),P=r===u?t.isActive:null;P===!1&&(S=m);let g=o===p[r]&&o!==l[r]&&V;if(g&&y&&e.manuallyAnimateOnMount&&(g=!1),t.protectedKeys={...d},!t.isActive&&P===null||!o&&!t.prevProp||_.isAnimationControls(o)||typeof o=="boolean")continue;const q=L(t.prevProp,o);let w=q||r===u&&t.isActive&&!g&&V||m>S&&V;const I=Array.isArray(o)?o:[o];let h=I.reduce(M,{});P===!1&&(h={});const{prevResolvedValues:O={}}=t,F={...O,...h},C=n=>{w=!0,a.delete(n),t.needsAnimating[n]=!0};for(const n in F){const A=h[n],K=O[n];d.hasOwnProperty(n)||(A!==K?k.isKeyframesTarget(A)&&k.isKeyframesTarget(K)?!D.shallowCompare(A,K)||q?C(n):t.protectedKeys[n]=!0:A!==void 0?C(n):a.add(n):A!==void 0&&a.has(n)?C(n):t.protectedKeys[n]=!0)}t.prevProp=o,t.prevResolvedValues=h,t.isActive&&(d={...d,...h}),y&&e.blockInitialAnimation&&(w=!1),w&&!g&&f.push(...I.map(n=>({animation:n,options:{type:r,...i}})))}if(a.size){const m={};a.forEach(r=>{const t=e.getBaseTarget(r);t!==void 0&&(m[r]=t)}),f.push({animation:m})}let b=!!f.length;return y&&l.initial===!1&&!e.manuallyAnimateOnMount&&(b=!1),y=!1,b?s(f):Promise.resolve()}function B(i,u,l){var p;if(c[i].isActive===u)return Promise.resolve();(p=e.variantChildren)===null||p===void 0||p.forEach(a=>{var d;return(d=a.animationState)===null||d===void 0?void 0:d.setActive(i,u)}),c[i].isActive=u;const f=T(l,i);for(const a in c)c[a].protectedKeys={};return f}return{animateChanges:T,setActive:B,setAnimateFunction:x,getState:()=>c}}function L(e,s){return typeof s=="string"?s!==e:Array.isArray(s)?!D.shallowCompare(s,e):!1}function v(e=!1){return{isActive:e,protectedKeys:{},needsAnimating:{},prevResolvedValues:{}}}function U(){return{animate:v(!0),whileInView:v(),whileHover:v(),whileTap:v(),whileDrag:v(),whileFocus:v(),exit:v()}}exports.checkVariantsDidChange=L;exports.createAnimationState=Q;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function c(r,o,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?r+(o-r)*6*e:e<1/2?o:e<2/3?r+(o-r)*(2/3-e)*6:r}function M({hue:r,saturation:o,lightness:e,alpha:l}){r/=360,o/=100,e/=100;let u=0,n=0,b=0;if(!o)u=n=b=e;else{const f=e<.5?e*(1+o):e+o-e*o,d=2*e-f;u=c(d,f,r+1/3),n=c(d,f,r),b=c(d,f,r-1/3)}return{red:Math.round(u*255),green:Math.round(n*255),blue:Math.round(b*255),alpha:l}}exports.hslaToRgba=M;

package/dist/lyra311.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra311.cjs","sources":["../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs"],"sourcesContent":["import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        const props = visualElement.getProps();\n        const context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n"],"names":["reversePriorityOrder","variantPriorityOrder","numAnimationTypes","animateList","visualElement","animations","animation","options","animateVisualElement","createAnimationState","animate","state","createState","isInitialRender","buildResolvedTypeValues","acc","definition","resolved","resolveVariant","transition","transitionEnd","target","setAnimateFunction","makeAnimator","animateChanges","changedActiveType","props","context","removedKeys","encounteredKeys","removedVariantIndex","i","type","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isInherited","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","key","next","prev","isKeyframesTarget","shallowCompare","fallbackAnimation","fallbackTarget","shouldAnimate","setActive","isActive","_a","child","createTypeState"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra311.cjs","sources":["../node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs"],"sourcesContent":["// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n"],"names":["hueToRgb","p","q","t","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue"],"mappings":"gFACA,SAASA,EAASC,EAAGC,EAAGC,EAAG,CAKvB,OAJIA,EAAI,IACJA,GAAK,GACLA,EAAI,IACJA,GAAK,GACLA,EAAI,EAAI,EACDF,GAAKC,EAAID,GAAK,EAAIE,EACzBA,EAAI,EAAI,EACDD,EACPC,EAAI,EAAI,EACDF,GAAKC,EAAID,IAAM,EAAI,EAAIE,GAAK,EAChCF,CACX,CACA,SAASG,EAAW,CAAE,IAAAC,EAAK,WAAAC,EAAY,UAAAC,EAAW,MAAAC,CAAK,EAAI,CACvDH,GAAO,IACPC,GAAc,IACdC,GAAa,IACb,IAAIE,EAAM,EACNC,EAAQ,EACRC,EAAO,EACX,GAAI,CAACL,EACDG,EAAMC,EAAQC,EAAOJ,MAEpB,CACD,MAAML,EAAIK,EAAY,GAChBA,GAAa,EAAID,GACjBC,EAAYD,EAAaC,EAAYD,EACrCL,EAAI,EAAIM,EAAYL,EAC1BO,EAAMT,EAASC,EAAGC,EAAGG,EAAM,EAAI,CAAC,EAChCK,EAAQV,EAASC,EAAGC,EAAGG,CAAG,EAC1BM,EAAOX,EAASC,EAAGC,EAAGG,EAAM,EAAI,CAAC,CACpC,CACD,MAAO,CACH,IAAK,KAAK,MAAMI,EAAM,GAAG,EACzB,MAAO,KAAK,MAAMC,EAAQ,GAAG,EAC7B,KAAM,KAAK,MAAMC,EAAO,GAAG,EAC3B,MAAAH,CACR,CACA","x_google_ignoreList":[0]}

package/dist/lyra311.js

@@ -1,116 +1,22 @@
-import { isAnimationControls as _ } from "./lyra265.js";
-import { isKeyframesTarget as R } from "./lyra294.js";
-import { shallowCompare as D } from "./lyra363.js";
-import { isVariantLabel as z } from "./lyra203.js";
-import { resolveVariant as H } from "./lyra176.js";
-import { variantPriorityOrder as x } from "./lyra208.js";
-import { animateVisualElement as j } from "./lyra175.js";
-const q = [...x].reverse(), G = x.length;
-function J(e) {
-  return (s) => Promise.all(s.map(({ animation: f, options: y }) => j(e, f, y)));
+function c(e, f, r) {
+  return r < 0 && (r += 1), r > 1 && (r -= 1), r < 1 / 6 ? e + (f - e) * 6 * r : r < 1 / 2 ? f : r < 2 / 3 ? e + (f - e) * (2 / 3 - r) * 6 : e;
 }
-function ee(e) {
-  let s = J(e);
-  const f = Q();
-  let y = !0;
-  const L = (i, c) => {
-    const l = H(e, c);
-    if (l) {
-      const { transition: p, transitionEnd: u, ...o } = l;
-      i = { ...i, ...o, ...u };
-    }
-    return i;
-  };
-  function B(i) {
-    s = i(e);
-  }
-  function C(i, c) {
-    const l = e.getProps(), p = e.getVariantContext(!0) || {}, u = [], o = /* @__PURE__ */ new Set();
-    let d = {}, I = 1 / 0;
-    for (let m = 0; m < G; m++) {
-      const r = q[m], t = f[r], a = l[r] !== void 0 ? l[r] : p[r], V = z(a), P = r === c ? t.isActive : null;
-      P === !1 && (I = m);
-      let g = a === p[r] && a !== l[r] && V;
-      if (g && y && e.manuallyAnimateOnMount && (g = !1), t.protectedKeys = { ...d }, // If it isn't active and hasn't *just* been set as inactive
-      !t.isActive && P === null || // If we didn't and don't have any defined prop for this animation type
-      !a && !t.prevProp || // Or if the prop doesn't define an animation
-      _(a) || typeof a == "boolean")
-        continue;
-      const b = N(t.prevProp, a);
-      let w = b || // If we're making this variant active, we want to always make it active
-      r === c && t.isActive && !g && V || // If we removed a higher-priority variant (i is in reverse order)
-      m > I && V;
-      const k = Array.isArray(a) ? a : [a];
-      let A = k.reduce(L, {});
-      P === !1 && (A = {});
-      const { prevResolvedValues: O = {} } = t, M = {
-        ...O,
-        ...A
-      }, K = (n) => {
-        w = !0, o.delete(n), t.needsAnimating[n] = !0;
-      };
-      for (const n in M) {
-        const h = A[n], T = O[n];
-        d.hasOwnProperty(n) || (h !== T ? R(h) && R(T) ? !D(h, T) || b ? K(n) : t.protectedKeys[n] = !0 : h !== void 0 ? K(n) : o.add(n) : h !== void 0 && o.has(n) ? K(n) : t.protectedKeys[n] = !0);
-      }
-      t.prevProp = a, t.prevResolvedValues = A, t.isActive && (d = { ...d, ...A }), y && e.blockInitialAnimation && (w = !1), w && !g && u.push(...k.map((n) => ({
-        animation: n,
-        options: { type: r, ...i }
-      })));
-    }
-    if (o.size) {
-      const m = {};
-      o.forEach((r) => {
-        const t = e.getBaseTarget(r);
-        t !== void 0 && (m[r] = t);
-      }), u.push({ animation: m });
-    }
-    let S = !!u.length;
-    return y && l.initial === !1 && !e.manuallyAnimateOnMount && (S = !1), y = !1, S ? s(u) : Promise.resolve();
-  }
-  function F(i, c, l) {
-    var p;
-    if (f[i].isActive === c)
-      return Promise.resolve();
-    (p = e.variantChildren) === null || p === void 0 || p.forEach((o) => {
-      var d;
-      return (d = o.animationState) === null || d === void 0 ? void 0 : d.setActive(i, c);
-    }), f[i].isActive = c;
-    const u = C(l, i);
-    for (const o in f)
-      f[o].protectedKeys = {};
-    return u;
+function R({ hue: e, saturation: f, lightness: r, alpha: M }) {
+  e /= 360, f /= 100, r /= 100;
+  let o = 0, u = 0, d = 0;
+  if (!f)
+    o = u = d = r;
+  else {
+    const n = r < 0.5 ? r * (1 + f) : r + f - r * f, b = 2 * r - n;
+    o = c(b, n, e + 1 / 3), u = c(b, n, e), d = c(b, n, e - 1 / 3);
   }
   return {
-    animateChanges: C,
-    setActive: F,
-    setAnimateFunction: B,
-    getState: () => f
-  };
-}
-function N(e, s) {
-  return typeof s == "string" ? s !== e : Array.isArray(s) ? !D(s, e) : !1;
-}
-function v(e = !1) {
-  return {
-    isActive: e,
-    protectedKeys: {},
-    needsAnimating: {},
-    prevResolvedValues: {}
-  };
-}
-function Q() {
-  return {
-    animate: v(!0),
-    whileInView: v(),
-    whileHover: v(),
-    whileTap: v(),
-    whileDrag: v(),
-    whileFocus: v(),
-    exit: v()
+    red: Math.round(o * 255),
+    green: Math.round(u * 255),
+    blue: Math.round(d * 255),
+    alpha: M
   };
 }
 export {
-  N as checkVariantsDidChange,
-  ee as createAnimationState
+  R as hslaToRgba
 };

package/dist/lyra311.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra311.js","sources":["../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs"],"sourcesContent":["import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        const props = visualElement.getProps();\n        const context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n"],"names":["reversePriorityOrder","variantPriorityOrder","numAnimationTypes","animateList","visualElement","animations","animation","options","animateVisualElement","createAnimationState","animate","state","createState","isInitialRender","buildResolvedTypeValues","acc","definition","resolved","resolveVariant","transition","transitionEnd","target","setAnimateFunction","makeAnimator","animateChanges","changedActiveType","props","context","removedKeys","encounteredKeys","removedVariantIndex","i","type","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isInherited","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","key","next","prev","isKeyframesTarget","shallowCompare","fallbackAnimation","fallbackTarget","shouldAnimate","setActive","isActive","_a","child","createTypeState"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra311.js","sources":["../node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs"],"sourcesContent":["// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n"],"names":["hueToRgb","p","q","t","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue"],"mappings":"AACA,SAASA,EAASC,GAAGC,GAAGC,GAAG;AAKvB,SAJIA,IAAI,MACJA,KAAK,IACLA,IAAI,MACJA,KAAK,IACLA,IAAI,IAAI,IACDF,KAAKC,IAAID,KAAK,IAAIE,IACzBA,IAAI,IAAI,IACDD,IACPC,IAAI,IAAI,IACDF,KAAKC,IAAID,MAAM,IAAI,IAAIE,KAAK,IAChCF;AACX;AACA,SAASG,EAAW,EAAE,KAAAC,GAAK,YAAAC,GAAY,WAAAC,GAAW,OAAAC,EAAK,GAAI;AACvD,EAAAH,KAAO,KACPC,KAAc,KACdC,KAAa;AACb,MAAIE,IAAM,GACNC,IAAQ,GACRC,IAAO;AACX,MAAI,CAACL;AACD,IAAAG,IAAMC,IAAQC,IAAOJ;AAAA,OAEpB;AACD,UAAML,IAAIK,IAAY,MAChBA,KAAa,IAAID,KACjBC,IAAYD,IAAaC,IAAYD,GACrCL,IAAI,IAAIM,IAAYL;AAC1B,IAAAO,IAAMT,EAASC,GAAGC,GAAGG,IAAM,IAAI,CAAC,GAChCK,IAAQV,EAASC,GAAGC,GAAGG,CAAG,GAC1BM,IAAOX,EAASC,GAAGC,GAAGG,IAAM,IAAI,CAAC;AAAA,EACpC;AACD,SAAO;AAAA,IACH,KAAK,KAAK,MAAMI,IAAM,GAAG;AAAA,IACzB,OAAO,KAAK,MAAMC,IAAQ,GAAG;AAAA,IAC7B,MAAM,KAAK,MAAMC,IAAO,GAAG;AAAA,IAC3B,OAAAH;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/lyra312.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class t{constructor(e){this.isMounted=!1,this.node=e}update(){}}exports.Feature=t;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const _=require("./lyra265.cjs"),k=require("./lyra295.cjs"),D=require("./lyra364.cjs"),j=require("./lyra203.cjs"),z=require("./lyra176.cjs"),R=require("./lyra208.cjs"),H=require("./lyra175.cjs"),G=[...R.variantPriorityOrder].reverse(),J=R.variantPriorityOrder.length;function N(e){return s=>Promise.all(s.map(({animation:c,options:y})=>H.animateVisualElement(e,c,y)))}function Q(e){let s=N(e);const c=U();let y=!0;const M=(i,u)=>{const l=z.resolveVariant(e,u);if(l){const{transition:p,transitionEnd:f,...a}=l;i={...i,...a,...f}}return i};function x(i){s=i(e)}function T(i,u){const l=e.getProps(),p=e.getVariantContext(!0)||{},f=[],a=new Set;let d={},S=1/0;for(let m=0;m<J;m++){const r=G[m],t=c[r],o=l[r]!==void 0?l[r]:p[r],V=j.isVariantLabel(o),P=r===u?t.isActive:null;P===!1&&(S=m);let g=o===p[r]&&o!==l[r]&&V;if(g&&y&&e.manuallyAnimateOnMount&&(g=!1),t.protectedKeys={...d},!t.isActive&&P===null||!o&&!t.prevProp||_.isAnimationControls(o)||typeof o=="boolean")continue;const q=L(t.prevProp,o);let w=q||r===u&&t.isActive&&!g&&V||m>S&&V;const I=Array.isArray(o)?o:[o];let h=I.reduce(M,{});P===!1&&(h={});const{prevResolvedValues:O={}}=t,F={...O,...h},C=n=>{w=!0,a.delete(n),t.needsAnimating[n]=!0};for(const n in F){const A=h[n],K=O[n];d.hasOwnProperty(n)||(A!==K?k.isKeyframesTarget(A)&&k.isKeyframesTarget(K)?!D.shallowCompare(A,K)||q?C(n):t.protectedKeys[n]=!0:A!==void 0?C(n):a.add(n):A!==void 0&&a.has(n)?C(n):t.protectedKeys[n]=!0)}t.prevProp=o,t.prevResolvedValues=h,t.isActive&&(d={...d,...h}),y&&e.blockInitialAnimation&&(w=!1),w&&!g&&f.push(...I.map(n=>({animation:n,options:{type:r,...i}})))}if(a.size){const m={};a.forEach(r=>{const t=e.getBaseTarget(r);t!==void 0&&(m[r]=t)}),f.push({animation:m})}let b=!!f.length;return y&&l.initial===!1&&!e.manuallyAnimateOnMount&&(b=!1),y=!1,b?s(f):Promise.resolve()}function B(i,u,l){var p;if(c[i].isActive===u)return Promise.resolve();(p=e.variantChildren)===null||p===void 0||p.forEach(a=>{var d;return(d=a.animationState)===null||d===void 0?void 0:d.setActive(i,u)}),c[i].isActive=u;const f=T(l,i);for(const a in c)c[a].protectedKeys={};return f}return{animateChanges:T,setActive:B,setAnimateFunction:x,getState:()=>c}}function L(e,s){return typeof s=="string"?s!==e:Array.isArray(s)?!D.shallowCompare(s,e):!1}function v(e=!1){return{isActive:e,protectedKeys:{},needsAnimating:{},prevResolvedValues:{}}}function U(){return{animate:v(!0),whileInView:v(),whileHover:v(),whileTap:v(),whileDrag:v(),whileFocus:v(),exit:v()}}exports.checkVariantsDidChange=L;exports.createAnimationState=Q;

package/dist/lyra312.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra312.cjs","sources":["../node_modules/framer-motion/dist/es/motion/features/Feature.mjs"],"sourcesContent":["class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n"],"names":["Feature","node"],"mappings":"gFAAA,MAAMA,CAAQ,CACV,YAAYC,EAAM,CACd,KAAK,UAAY,GACjB,KAAK,KAAOA,CACf,CACD,QAAS,CAAG,CAChB","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra312.cjs","sources":["../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs"],"sourcesContent":["import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        const props = visualElement.getProps();\n        const context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n"],"names":["reversePriorityOrder","variantPriorityOrder","numAnimationTypes","animateList","visualElement","animations","animation","options","animateVisualElement","createAnimationState","animate","state","createState","isInitialRender","buildResolvedTypeValues","acc","definition","resolved","resolveVariant","transition","transitionEnd","target","setAnimateFunction","makeAnimator","animateChanges","changedActiveType","props","context","removedKeys","encounteredKeys","removedVariantIndex","i","type","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isInherited","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","key","next","prev","isKeyframesTarget","shallowCompare","fallbackAnimation","fallbackTarget","shouldAnimate","setActive","isActive","_a","child","createTypeState"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lyra312.js

@@ -1,10 +1,116 @@
-class s {
-  constructor(t) {
-    this.isMounted = !1, this.node = t;
+import { isAnimationControls as _ } from "./lyra265.js";
+import { isKeyframesTarget as R } from "./lyra295.js";
+import { shallowCompare as D } from "./lyra364.js";
+import { isVariantLabel as z } from "./lyra203.js";
+import { resolveVariant as H } from "./lyra176.js";
+import { variantPriorityOrder as x } from "./lyra208.js";
+import { animateVisualElement as j } from "./lyra175.js";
+const q = [...x].reverse(), G = x.length;
+function J(e) {
+  return (s) => Promise.all(s.map(({ animation: f, options: y }) => j(e, f, y)));
+}
+function ee(e) {
+  let s = J(e);
+  const f = Q();
+  let y = !0;
+  const L = (i, c) => {
+    const l = H(e, c);
+    if (l) {
+      const { transition: p, transitionEnd: u, ...o } = l;
+      i = { ...i, ...o, ...u };
+    }
+    return i;
+  };
+  function B(i) {
+    s = i(e);
+  }
+  function C(i, c) {
+    const l = e.getProps(), p = e.getVariantContext(!0) || {}, u = [], o = /* @__PURE__ */ new Set();
+    let d = {}, I = 1 / 0;
+    for (let m = 0; m < G; m++) {
+      const r = q[m], t = f[r], a = l[r] !== void 0 ? l[r] : p[r], V = z(a), P = r === c ? t.isActive : null;
+      P === !1 && (I = m);
+      let g = a === p[r] && a !== l[r] && V;
+      if (g && y && e.manuallyAnimateOnMount && (g = !1), t.protectedKeys = { ...d }, // If it isn't active and hasn't *just* been set as inactive
+      !t.isActive && P === null || // If we didn't and don't have any defined prop for this animation type
+      !a && !t.prevProp || // Or if the prop doesn't define an animation
+      _(a) || typeof a == "boolean")
+        continue;
+      const b = N(t.prevProp, a);
+      let w = b || // If we're making this variant active, we want to always make it active
+      r === c && t.isActive && !g && V || // If we removed a higher-priority variant (i is in reverse order)
+      m > I && V;
+      const k = Array.isArray(a) ? a : [a];
+      let A = k.reduce(L, {});
+      P === !1 && (A = {});
+      const { prevResolvedValues: O = {} } = t, M = {
+        ...O,
+        ...A
+      }, K = (n) => {
+        w = !0, o.delete(n), t.needsAnimating[n] = !0;
+      };
+      for (const n in M) {
+        const h = A[n], T = O[n];
+        d.hasOwnProperty(n) || (h !== T ? R(h) && R(T) ? !D(h, T) || b ? K(n) : t.protectedKeys[n] = !0 : h !== void 0 ? K(n) : o.add(n) : h !== void 0 && o.has(n) ? K(n) : t.protectedKeys[n] = !0);
+      }
+      t.prevProp = a, t.prevResolvedValues = A, t.isActive && (d = { ...d, ...A }), y && e.blockInitialAnimation && (w = !1), w && !g && u.push(...k.map((n) => ({
+        animation: n,
+        options: { type: r, ...i }
+      })));
+    }
+    if (o.size) {
+      const m = {};
+      o.forEach((r) => {
+        const t = e.getBaseTarget(r);
+        t !== void 0 && (m[r] = t);
+      }), u.push({ animation: m });
+    }
+    let S = !!u.length;
+    return y && l.initial === !1 && !e.manuallyAnimateOnMount && (S = !1), y = !1, S ? s(u) : Promise.resolve();
   }
-  update() {
+  function F(i, c, l) {
+    var p;
+    if (f[i].isActive === c)
+      return Promise.resolve();
+    (p = e.variantChildren) === null || p === void 0 || p.forEach((o) => {
+      var d;
+      return (d = o.animationState) === null || d === void 0 ? void 0 : d.setActive(i, c);
+    }), f[i].isActive = c;
+    const u = C(l, i);
+    for (const o in f)
+      f[o].protectedKeys = {};
+    return u;
   }
+  return {
+    animateChanges: C,
+    setActive: F,
+    setAnimateFunction: B,
+    getState: () => f
+  };
+}
+function N(e, s) {
+  return typeof s == "string" ? s !== e : Array.isArray(s) ? !D(s, e) : !1;
+}
+function v(e = !1) {
+  return {
+    isActive: e,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function Q() {
+  return {
+    animate: v(!0),
+    whileInView: v(),
+    whileHover: v(),
+    whileTap: v(),
+    whileDrag: v(),
+    whileFocus: v(),
+    exit: v()
+  };
 }
 export {
-  s as Feature
+  N as checkVariantsDidChange,
+  ee as createAnimationState
 };

package/dist/lyra312.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra312.js","sources":["../node_modules/framer-motion/dist/es/motion/features/Feature.mjs"],"sourcesContent":["class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n"],"names":["Feature","node"],"mappings":"AAAA,MAAMA,EAAQ;AAAA,EACV,YAAYC,GAAM;AACd,SAAK,YAAY,IACjB,KAAK,OAAOA;AAAA,EACf;AAAA,EACD,SAAS;AAAA,EAAG;AAChB;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra312.js","sources":["../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs"],"sourcesContent":["import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        const props = visualElement.getProps();\n        const context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n"],"names":["reversePriorityOrder","variantPriorityOrder","numAnimationTypes","animateList","visualElement","animations","animation","options","animateVisualElement","createAnimationState","animate","state","createState","isInitialRender","buildResolvedTypeValues","acc","definition","resolved","resolveVariant","transition","transitionEnd","target","setAnimateFunction","makeAnimator","animateChanges","changedActiveType","props","context","removedKeys","encounteredKeys","removedVariantIndex","i","type","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isInherited","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","key","next","prev","isKeyframesTarget","shallowCompare","fallbackAnimation","fallbackTarget","shouldAnimate","setActive","isActive","_a","child","createTypeState"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lyra313.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./lyra227.cjs"),s=require("./lyra223.cjs"),c=new Set(["brightness","contrast","saturate","opacity"]);function u(t){const[e,n]=t.slice(0,-1).split("(");if(e==="drop-shadow")return t;const[r]=n.match(s.floatRegex)||[];if(!r)return t;const o=n.replace(r,"");let a=c.has(e)?1:0;return r!==n&&(a*=100),e+"("+a+o+")"}const l=/([a-z-]*)\(.*?\)/g,f={...i.complex,getAnimatableNone:t=>{const e=t.match(l);return e?e.map(u).join(" "):t}};exports.filter=f;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class t{constructor(e){this.isMounted=!1,this.node=e}update(){}}exports.Feature=t;

package/dist/lyra313.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lyra313.cjs","sources":["../node_modules/framer-motion/dist/es/value/types/complex/filter.mjs"],"sourcesContent":["import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n"],"names":["maxDefaults","applyDefaultFilter","v","name","value","number","floatRegex","unit","defaultValue","functionRegex","filter","complex","functions"],"mappings":"4IAMMA,EAAc,IAAI,IAAI,CAAC,aAAc,WAAY,WAAY,SAAS,CAAC,EAC7E,SAASC,EAAmBC,EAAG,CAC3B,KAAM,CAACC,EAAMC,CAAK,EAAIF,EAAE,MAAM,EAAG,EAAE,EAAE,MAAM,GAAG,EAC9C,GAAIC,IAAS,cACT,OAAOD,EACX,KAAM,CAACG,CAAM,EAAID,EAAM,MAAME,EAAAA,UAAU,GAAK,GAC5C,GAAI,CAACD,EACD,OAAOH,EACX,MAAMK,EAAOH,EAAM,QAAQC,EAAQ,EAAE,EACrC,IAAIG,EAAeR,EAAY,IAAIG,CAAI,EAAI,EAAI,EAC/C,OAAIE,IAAWD,IACXI,GAAgB,KACbL,EAAO,IAAMK,EAAeD,EAAO,GAC9C,CACA,MAAME,EAAgB,oBAChBC,EAAS,CACX,GAAGC,EAAO,QACV,kBAAoBT,GAAM,CACtB,MAAMU,EAAYV,EAAE,MAAMO,CAAa,EACvC,OAAOG,EAAYA,EAAU,IAAIX,CAAkB,EAAE,KAAK,GAAG,EAAIC,CACpE,CACL","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra313.cjs","sources":["../node_modules/framer-motion/dist/es/motion/features/Feature.mjs"],"sourcesContent":["class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n"],"names":["Feature","node"],"mappings":"gFAAA,MAAMA,CAAQ,CACV,YAAYC,EAAM,CACd,KAAK,UAAY,GACjB,KAAK,KAAOA,CACf,CACD,QAAS,CAAG,CAChB","x_google_ignoreList":[0]}

package/dist/lyra313.js

@@ -1,24 +1,10 @@
-import { complex as c } from "./lyra227.js";
-import { floatRegex as i } from "./lyra223.js";
-const s = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
-function l(t) {
-  const [e, n] = t.slice(0, -1).split("(");
-  if (e === "drop-shadow")
-    return t;
-  const [o] = n.match(i) || [];
-  if (!o)
-    return t;
-  const r = n.replace(o, "");
-  let a = s.has(e) ? 1 : 0;
-  return o !== n && (a *= 100), e + "(" + a + r + ")";
-}
-const u = /([a-z-]*)\(.*?\)/g, p = {
-  ...c,
-  getAnimatableNone: (t) => {
-    const e = t.match(u);
-    return e ? e.map(l).join(" ") : t;
+class s {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
   }
-};
+  update() {
+  }
+}
 export {
-  p as filter
+  s as Feature
 };

package/dist/lyra313.js.map

@@ -1 +1 @@
-{"version":3,"file":"lyra313.js","sources":["../node_modules/framer-motion/dist/es/value/types/complex/filter.mjs"],"sourcesContent":["import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n"],"names":["maxDefaults","applyDefaultFilter","v","name","value","number","floatRegex","unit","defaultValue","functionRegex","filter","complex","functions"],"mappings":";;AAMA,MAAMA,IAAc,oBAAI,IAAI,CAAC,cAAc,YAAY,YAAY,SAAS,CAAC;AAC7E,SAASC,EAAmBC,GAAG;AAC3B,QAAM,CAACC,GAAMC,CAAK,IAAIF,EAAE,MAAM,GAAG,EAAE,EAAE,MAAM,GAAG;AAC9C,MAAIC,MAAS;AACT,WAAOD;AACX,QAAM,CAACG,CAAM,IAAID,EAAM,MAAME,CAAU,KAAK;AAC5C,MAAI,CAACD;AACD,WAAOH;AACX,QAAMK,IAAOH,EAAM,QAAQC,GAAQ,EAAE;AACrC,MAAIG,IAAeR,EAAY,IAAIG,CAAI,IAAI,IAAI;AAC/C,SAAIE,MAAWD,MACXI,KAAgB,MACbL,IAAO,MAAMK,IAAeD,IAAO;AAC9C;AACA,MAAME,IAAgB,qBAChBC,IAAS;AAAA,EACX,GAAGC;AAAA,EACH,mBAAmB,CAACT,MAAM;AACtB,UAAMU,IAAYV,EAAE,MAAMO,CAAa;AACvC,WAAOG,IAAYA,EAAU,IAAIX,CAAkB,EAAE,KAAK,GAAG,IAAIC;AAAA,EACpE;AACL;","x_google_ignoreList":[0]}
+{"version":3,"file":"lyra313.js","sources":["../node_modules/framer-motion/dist/es/motion/features/Feature.mjs"],"sourcesContent":["class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n"],"names":["Feature","node"],"mappings":"AAAA,MAAMA,EAAQ;AAAA,EACV,YAAYC,GAAM;AACd,SAAK,YAAY,IACjB,KAAK,OAAOA;AAAA,EACf;AAAA,EACD,SAAS;AAAA,EAAG;AAChB;","x_google_ignoreList":[0]}

package/dist/lyra314.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./lyra222.cjs"),r=require("./lyra313.cjs"),t=require("./lyra364.cjs"),e={...t.numberValueTypes,color:o.color,backgroundColor:o.color,outlineColor:o.color,fill:o.color,stroke:o.color,borderColor:o.color,borderTopColor:o.color,borderRightColor:o.color,borderBottomColor:o.color,borderLeftColor:o.color,filter:r.filter,WebkitFilter:r.filter},c=l=>e[l];exports.defaultValueTypes=e;exports.getDefaultValueType=c;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./lyra227.cjs"),s=require("./lyra223.cjs"),c=new Set(["brightness","contrast","saturate","opacity"]);function u(t){const[e,n]=t.slice(0,-1).split("(");if(e==="drop-shadow")return t;const[r]=n.match(s.floatRegex)||[];if(!r)return t;const o=n.replace(r,"");let a=c.has(e)?1:0;return r!==n&&(a*=100),e+"("+a+o+")"}const l=/([a-z-]*)\(.*?\)/g,f={...i.complex,getAnimatableNone:t=>{const e=t.match(l);return e?e.map(u).join(" "):t}};exports.filter=f;