@burdenoff/microfe-mybodyshield 2026.1028.1 → 2026.1101.2

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

@@ -1 +1 @@
-{"version":3,"file":"spring.js","names":[],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/spring.mjs"],"sourcesContent":["import { millisecondsToSeconds, clamp, secondsToMilliseconds, warning } from 'motion-utils';\nimport { generateLinearEasing } from '../waapi/utils/linear.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './utils/calc-duration.mjs';\nimport { createGeneratorEasing } from './utils/create-generator-easing.mjs';\n\nconst springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\n/**\n * This is ported from the Framer implementation of duration-based spring resolution.\n */\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\", \"spring-duration-limit\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        // Time-defined springs should ignore inherited velocity.\n        // Velocity from interrupted animations can cause findSpring()\n        // to compute wildly different spring parameters, leading to\n        // massive oscillation on small-range animations.\n        springOptions.velocity = 0;\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring({ ...options, velocity: 0 });\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    let resolveVelocity;\n    // Underdamped coefficients, hoisted for use in the inlined next() hot path\n    let angularFreq;\n    let A;\n    let sinCoeff;\n    let cosCoeff;\n    if (dampingRatio < 1) {\n        angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        A =\n            (initialVelocity +\n                dampingRatio * undampedAngularFreq * initialDelta) /\n                angularFreq;\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (A * Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n        // Analytical derivative of underdamped spring (px/ms)\n        sinCoeff =\n            dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;\n        cosCoeff =\n            dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return envelope *\n                (sinCoeff * Math.sin(angularFreq * t) +\n                    cosCoeff * Math.cos(angularFreq * t));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n        // Analytical derivative of critically damped spring (px/ms)\n        const C = initialVelocity + undampedAngularFreq * initialDelta;\n        resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) *\n            (undampedAngularFreq * C * t - initialVelocity);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n        // Analytical derivative of overdamped spring (px/ms)\n        const P = (initialVelocity +\n            dampingRatio * undampedAngularFreq * initialDelta) /\n            dampedAngularFreq;\n        const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;\n        const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return envelope *\n                (sinhCoeff * Math.sinh(freqForT) +\n                    coshCoeff * Math.cosh(freqForT));\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),\n        next: (t) => {\n            /**\n             * For underdamped physics springs we need both position and\n             * velocity each tick. Compute shared trig values once to avoid\n             * duplicate Math.exp/sin/cos calls on the hot path.\n             */\n            if (!isResolvedFromDuration && dampingRatio < 1) {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const sin = Math.sin(angularFreq * t);\n                const cos = Math.cos(angularFreq * t);\n                const current = target -\n                    envelope *\n                        (A * sin + initialDelta * cos);\n                const currentVelocity = secondsToMilliseconds(envelope *\n                    (sinCoeff * sin + cosCoeff * cos));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n                state.value = state.done ? target : current;\n                return state;\n            }\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = secondsToMilliseconds(resolveVelocity(t));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n        toTransition: () => { },\n    };\n    return generator;\n}\nspring.applyToOptions = (options) => {\n    const generatorOptions = createGeneratorEasing(options, 100, spring);\n    options.ease = generatorOptions.ease;\n    options.duration = secondsToMilliseconds(generatorOptions.duration);\n    options.type = \"keyframes\";\n    return options;\n};\n\nexport { spring };\n//# sourceMappingURL=spring.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAKA,IAAM,IAAiB;CAEnB,WAAW;CACX,SAAS;CACT,MAAM;CACN,UAAU;CAEV,UAAU;CACV,QAAQ;CACR,gBAAgB;CAEhB,WAAW;EACP,UAAU;EACV,SAAS;EACZ;CACD,WAAW;EACP,UAAU;EACV,SAAS;EACZ;CAED,aAAa;CACb,aAAa;CACb,YAAY;CACZ,YAAY;CACf;AACD,SAAS,EAAgB,GAAc,GAAc;AACjD,QAAO,IAAe,KAAK,KAAK,IAAI,IAAe,EAAa;;AAEpE,IAAM,IAAiB;AACvB,SAAS,EAAgB,GAAU,GAAY,GAAc;CACzD,IAAI,IAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,GAAgB,IAChC,MAAkB,EAAS,EAAO,GAAG,EAAW,EAAO;AAE3D,QAAO;;AAKX,IAAM,IAAU;AAChB,SAAS,EAAW,EAAE,cAAW,EAAe,UAAU,YAAS,EAAe,QAAQ,cAAW,EAAe,UAAU,UAAO,EAAe,QAAS;CACzJ,IAAI,GACA;AACJ,GAAQ,KAAY,EAAsB,EAAe,YAAY,EAAE,8CAA8C,wBAAwB;CAC7I,IAAI,IAAe,IAAI;AAMvB,CAFA,IAAe,EAAM,EAAe,YAAY,EAAe,YAAY,EAAa,EACxF,IAAW,EAAM,EAAe,aAAa,EAAe,aAAa,EAAsB,EAAS,CAAC,EACrG,IAAe,KAIf,KAAY,MAAiB;EACzB,IAAM,IAAmB,IAAe,GAClC,IAAQ,IAAmB,GAC3B,IAAI,IAAmB,GACvB,IAAI,EAAgB,GAAc,EAAa,EAC/C,IAAI,KAAK,IAAI,CAAC,EAAM;AAC1B,SAAO,IAAW,IAAI,IAAK;IAE/B,KAAc,MAAiB;EAE3B,IAAM,IADmB,IAAe,IACP,GAC3B,IAAI,IAAQ,IAAW,GACvB,IAAa,KAAc,IAAc,KAAc,IAAK,GAC5D,IAAI,KAAK,IAAI,CAAC,EAAM,EACpB,IAAI,EAAyB,KAAc,GAAI,EAAa;AAElE,UADe,CAAC,EAAS,EAAa,GAAG,IAAU,IAAI,KAAK,OACzC,IAAI,KAAK,KAAM;OAOtC,KAAY,MAAiB;EACzB,IAAM,IAAI,KAAK,IAAI,CAAC,IAAe,EAAS,EACtC,KAAK,IAAe,KAAY,IAAW;AACjD,SAAO,CAAC,IAAU,IAAI;IAE1B,KAAc,MACA,KAAK,IAAI,CAAC,IAAe,EAAS,KACjC,IAAW,MAAiB,IAAW;CAI1D,IAAM,IAAe,IAAI,GACnB,IAAe,EAAgB,GAAU,GAAY,EAAa;AAExE,KADA,IAAW,EAAsB,EAAS,EACtC,MAAM,EAAa,CACnB,QAAO;EACH,WAAW,EAAe;EAC1B,SAAS,EAAe;EACxB;EACH;CAEA;EACD,IAAM,IAAqB,KAAc,IAAK;AAC9C,SAAO;GACH;GACA,SAAS,IAAe,IAAI,KAAK,KAAK,IAAO,EAAU;GACvD;GACH;;;AAGT,IAAM,IAAe,CAAC,YAAY,SAAS,EACrC,IAAc;CAAC;CAAa;CAAW;CAAO;AACpD,SAAS,EAAa,GAAS,GAAM;AACjC,QAAO,EAAK,MAAM,MAAQ,EAAQ,OAAS,KAAA,EAAU;;AAEzD,SAAS,EAAiB,GAAS;CAC/B,IAAI,IAAgB;EAChB,UAAU,EAAe;EACzB,WAAW,EAAe;EAC1B,SAAS,EAAe;EACxB,MAAM,EAAe;EACrB,wBAAwB;EACxB,GAAG;EACN;AAED,KAAI,CAAC,EAAa,GAAS,EAAY,IACnC,EAAa,GAAS,EAAa,CAMnC,KADA,EAAc,WAAW,GACrB,EAAQ,gBAAgB;EACxB,IAAM,IAAiB,EAAQ,gBACzB,IAAQ,IAAI,KAAK,MAAO,IAAiB,MACzC,IAAY,IAAO,GACnB,IAAU,IACZ,EAAM,KAAM,GAAG,KAAK,EAAQ,UAAU,GAAG,GACzC,KAAK,KAAK,EAAU;AACxB,MAAgB;GACZ,GAAG;GACH,MAAM,EAAe;GACrB;GACA;GACH;QAEA;EACD,IAAM,IAAU,EAAW;GAAE,GAAG;GAAS,UAAU;GAAG,CAAC;AAMvD,EALA,IAAgB;GACZ,GAAG;GACH,GAAG;GACH,MAAM,EAAe;GACxB,EACD,EAAc,yBAAyB;;AAG/C,QAAO;;AAEX,SAAS,EAAO,IAA0B,EAAe,gBAAgB,IAAS,EAAe,QAAQ;CACrG,IAAM,IAAU,OAAO,KAA4B,WAM7C,IALA;EACE,gBAAgB;EAChB,WAAW,CAAC,GAAG,EAAE;EACjB;EACH,EAED,EAAE,cAAW,iBAAc,GACzB,IAAS,EAAQ,UAAU,IAC3B,IAAS,EAAQ,UAAU,EAAQ,UAAU,SAAS,IAKtD,IAAQ;EAAE,MAAM;EAAO,OAAO;EAAQ,EACtC,EAAE,cAAW,YAAS,SAAM,aAAU,aAAU,8BAA4B,EAAiB;EAC/F,GAAG;EACH,UAAU,CAAC,EAAsB,EAAQ,YAAY,EAAE;EAC1D,CAAC,EACI,IAAkB,KAAY,GAC9B,IAAe,KAAW,IAAI,KAAK,KAAK,IAAY,EAAK,GACzD,IAAe,IAAS,GACxB,IAAsB,EAAsB,KAAK,KAAK,IAAY,EAAK,CAAC,EAQxE,IAAkB,KAAK,IAAI,EAAa,GAAG;AAIjD,CAHA,AAAc,MAAY,IACpB,EAAe,UAAU,WACzB,EAAe,UAAU,SAC/B,AAAc,MAAY,IACpB,EAAe,UAAU,WACzB,EAAe,UAAU;CAC/B,IAAI,GACA,GAEA,GACA,GACA,GACA;AACJ,KAAI,IAAe,EAmBf,CAlBA,IAAc,EAAgB,GAAqB,EAAa,EAChE,KACK,IACG,IAAe,IAAsB,KACrC,GAER,KAAiB,MAEL,IADS,KAAK,IAAI,CAAC,IAAe,IAAsB,EAAE,IAGzD,IAAI,KAAK,IAAI,IAAc,EAAE,GAC1B,IAAe,KAAK,IAAI,IAAc,EAAE,GAGxD,IACI,IAAe,IAAsB,IAAI,IAAe,GAC5D,IACI,IAAe,IAAsB,IAAe,IAAI,GAC5D,KAAmB,MACE,KAAK,IAAI,CAAC,IAAe,IAAsB,EAAE,IAE7D,IAAW,KAAK,IAAI,IAAc,EAAE,GACjC,IAAW,KAAK,IAAI,IAAc,EAAE;UAG3C,MAAiB,GAAG;AAEzB,OAAiB,MAAM,IACnB,KAAK,IAAI,CAAC,IAAsB,EAAE,IAC7B,KACI,IAAkB,IAAsB,KAAgB;EAErE,IAAM,IAAI,IAAkB,IAAsB;AAClD,OAAmB,MAAM,KAAK,IAAI,CAAC,IAAsB,EAAE,IACtD,IAAsB,IAAI,IAAI;QAElC;EAED,IAAM,IAAoB,IAAsB,KAAK,KAAK,IAAe,IAAe,EAAE;AAC1F,OAAiB,MAAM;GACnB,IAAM,IAAW,KAAK,IAAI,CAAC,IAAe,IAAsB,EAAE,EAE5D,IAAW,KAAK,IAAI,IAAoB,GAAG,IAAI;AACrD,UAAQ,IACH,MACK,IACE,IAAe,IAAsB,KACrC,KAAK,KAAK,EAAS,GACnB,IACI,IACA,KAAK,KAAK,EAAS,IAC3B;;EAGZ,IAAM,KAAK,IACP,IAAe,IAAsB,KACrC,GACE,IAAY,IAAe,IAAsB,IAAI,IAAe,GACpE,IAAY,IAAe,IAAsB,IAAe,IAAI;AAC1E,OAAmB,MAAM;GACrB,IAAM,IAAW,KAAK,IAAI,CAAC,IAAe,IAAsB,EAAE,EAC5D,IAAW,KAAK,IAAI,IAAoB,GAAG,IAAI;AACrD,UAAO,KACF,IAAY,KAAK,KAAK,EAAS,GAC5B,IAAY,KAAK,KAAK,EAAS;;;CAG/C,IAAM,IAAY;EACd,oBAAoB,KAAyB,KAAmB;EAChE,WAAW,MAAM,EAAsB,EAAgB,EAAE,CAAC;EAC1D,OAAO,MAAM;AAMT,OAAI,CAAC,KAA0B,IAAe,GAAG;IAC7C,IAAM,IAAW,KAAK,IAAI,CAAC,IAAe,IAAsB,EAAE,EAC5D,IAAM,KAAK,IAAI,IAAc,EAAE,EAC/B,IAAM,KAAK,IAAI,IAAc,EAAE,EAC/B,IAAU,IACZ,KACK,IAAI,IAAM,IAAe,IAC5B,IAAkB,EAAsB,KACzC,IAAW,IAAM,IAAW,GAAK;AAKtC,WAJA,EAAM,OACF,KAAK,IAAI,EAAgB,IAAI,KACzB,KAAK,IAAI,IAAS,EAAQ,IAAI,GACtC,EAAM,QAAQ,EAAM,OAAO,IAAS,GAC7B;;GAEX,IAAM,IAAU,EAAc,EAAE;AAChC,OAAK,EAOD,GAAM,OAAO,KAAK;QAPO;IACzB,IAAM,IAAkB,EAAsB,EAAgB,EAAE,CAAC;AACjE,MAAM,OACF,KAAK,IAAI,EAAgB,IAAI,KACzB,KAAK,IAAI,IAAS,EAAQ,IAAI;;AAM1C,UADA,EAAM,QAAQ,EAAM,OAAO,IAAS,GAC7B;;EAEX,gBAAgB;GACZ,IAAM,IAAqB,KAAK,IAAI,EAAsB,EAAU,EAAE,EAAqB,EACrF,IAAS,GAAsB,MAAa,EAAU,KAAK,IAAqB,EAAS,CAAC,OAAO,GAAoB,GAAG;AAC9H,UAAO,IAAqB,QAAQ;;EAExC,oBAAoB;EACvB;AACD,QAAO;;AAEX,EAAO,kBAAkB,MAAY;CACjC,IAAM,IAAmB,EAAsB,GAAS,KAAK,EAAO;AAIpE,QAHA,EAAQ,OAAO,EAAiB,MAChC,EAAQ,WAAW,EAAsB,EAAiB,SAAS,EACnE,EAAQ,OAAO,aACR"}
+{"version":3,"file":"spring.js","names":["springDefaults","calcAngularFreq","undampedFreq","dampingRatio","rootIterations","approximateRoot","result","initialGuess","i","envelope","derivative","safeMin","findSpring","duration","secondsToMilliseconds","bounce","clamp","millisecondsToSeconds","exponentialDecay","delta","a","velocity","b","c","d","e","f","g","stiffness","mass","durationKeys","physicsKeys","isSpringType","keys","options","key","getSpringOptions","springOptions","visualDuration","root","damping","derived","spring","optionsOrVisualDuration","origin","target","state","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","restSpeed","restDelta","resolveSpring","resolveVelocity","angularFreq","sinCoeff","cosCoeff","t","C","dampedAngularFreq","freqForT","P","sinhCoeff","coshCoeff","generator","isResolvedFromDuration","sin","cos","current","currentVelocity","calculatedDuration","calcGeneratorDuration","maxGeneratorDuration","easing","generateLinearEasing","progress","generatorOptions","createGeneratorEasing"],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/spring.mjs"],"sourcesContent":["import { millisecondsToSeconds, clamp, secondsToMilliseconds, warning } from 'motion-utils';\nimport { generateLinearEasing } from '../waapi/utils/linear.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './utils/calc-duration.mjs';\nimport { createGeneratorEasing } from './utils/create-generator-easing.mjs';\n\nconst springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\n/**\n * This is ported from the Framer implementation of duration-based spring resolution.\n */\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\", \"spring-duration-limit\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        // Time-defined springs should ignore inherited velocity.\n        // Velocity from interrupted animations can cause findSpring()\n        // to compute wildly different spring parameters, leading to\n        // massive oscillation on small-range animations.\n        springOptions.velocity = 0;\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring({ ...options, velocity: 0 });\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    let resolveVelocity;\n    // Underdamped coefficients, hoisted for use in the inlined next() hot path\n    let angularFreq;\n    let A;\n    let sinCoeff;\n    let cosCoeff;\n    if (dampingRatio < 1) {\n        angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        A =\n            (initialVelocity +\n                dampingRatio * undampedAngularFreq * initialDelta) /\n                angularFreq;\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (A * Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n        // Analytical derivative of underdamped spring (px/ms)\n        sinCoeff =\n            dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;\n        cosCoeff =\n            dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return envelope *\n                (sinCoeff * Math.sin(angularFreq * t) +\n                    cosCoeff * Math.cos(angularFreq * t));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n        // Analytical derivative of critically damped spring (px/ms)\n        const C = initialVelocity + undampedAngularFreq * initialDelta;\n        resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) *\n            (undampedAngularFreq * C * t - initialVelocity);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n        // Analytical derivative of overdamped spring (px/ms)\n        const P = (initialVelocity +\n            dampingRatio * undampedAngularFreq * initialDelta) /\n            dampedAngularFreq;\n        const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;\n        const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return envelope *\n                (sinhCoeff * Math.sinh(freqForT) +\n                    coshCoeff * Math.cosh(freqForT));\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),\n        next: (t) => {\n            /**\n             * For underdamped physics springs we need both position and\n             * velocity each tick. Compute shared trig values once to avoid\n             * duplicate Math.exp/sin/cos calls on the hot path.\n             */\n            if (!isResolvedFromDuration && dampingRatio < 1) {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const sin = Math.sin(angularFreq * t);\n                const cos = Math.cos(angularFreq * t);\n                const current = target -\n                    envelope *\n                        (A * sin + initialDelta * cos);\n                const currentVelocity = secondsToMilliseconds(envelope *\n                    (sinCoeff * sin + cosCoeff * cos));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n                state.value = state.done ? target : current;\n                return state;\n            }\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = secondsToMilliseconds(resolveVelocity(t));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n        toTransition: () => { },\n    };\n    return generator;\n}\nspring.applyToOptions = (options) => {\n    const generatorOptions = createGeneratorEasing(options, 100, spring);\n    options.ease = generatorOptions.ease;\n    options.duration = secondsToMilliseconds(generatorOptions.duration);\n    options.type = \"keyframes\";\n    return options;\n};\n\nexport { spring };\n//# sourceMappingURL=spring.mjs.map\n"],"ignoreList":[0],"mappings":"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"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.js

@@ -1,11 +1,10 @@
-//#region node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs
+// node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs
 var e = 2e4;
 function t(e) {
 	let t = 0, n = e.next(t);
 	for (; !n.done && t < 2e4;) t += 50, n = e.next(t);
 	return t >= 2e4 ? Infinity : t;
 }
-//#endregion
 export { t as calcGeneratorDuration, e as maxGeneratorDuration };
 
 //# sourceMappingURL=calc-duration.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.js.map

@@ -1 +1 @@
-{"version":3,"file":"calc-duration.js","names":[],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAIA,IAAM,IAAuB;AAC7B,SAAS,EAAsB,GAAW;CACtC,IAAI,IAAW,GAEX,IAAQ,EAAU,KAAK,EAAS;AACpC,QAAO,CAAC,EAAM,QAAQ,IAAA,KAElB,CADA,KAAY,IACZ,IAAQ,EAAU,KAAK,EAAS;AAEpC,QAAO,KAAA,MAAmC,WAAW"}
+{"version":3,"file":"calc-duration.js","names":["maxGeneratorDuration","calcGeneratorDuration","duration","state","generator"],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"ignoreList":[0],"mappings":";AAIA,IAAMA,IAAuB;AAC7B,SAASC,EAAsB,GAAW;CACtC,IAAIC,IAAW,GAEXC,IAAQC,EAAU,KAAKF,CAAQ;CACnC,OAAO,CAACC,EAAM,QAAQD,IAAA,MAElB,AADA,KAAY,IACZ,IAAQE,EAAU,KAAKF,CAAQ;CAEnC,OAAOA,KAAA,MAAmC,WAAWA;AACzD"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.js

@@ -1,6 +1,6 @@
 import { millisecondsToSeconds as e } from "../../../../../../motion-utils/dist/es/time-conversion.js";
 import { calcGeneratorDuration as t, maxGeneratorDuration as n } from "./calc-duration.js";
-//#region node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs
+// node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs
 function r(r, i = 100, a) {
 	let o = a({
 		...r,
@@ -12,7 +12,6 @@ function r(r, i = 100, a) {
 		duration: e(s)
 	};
 }
-//#endregion
 export { r as createGeneratorEasing };
 
 //# sourceMappingURL=create-generator-easing.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-generator-easing.js","names":[],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs"],"sourcesContent":["import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n//# sourceMappingURL=create-generator-easing.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;AAMA,SAAS,EAAsB,GAAS,IAAQ,KAAK,GAAiB;CAClE,IAAM,IAAY,EAAgB;EAAE,GAAG;EAAS,WAAW,CAAC,GAAG,EAAM;EAAE,CAAC,EAClE,IAAW,KAAK,IAAI,EAAsB,EAAU,EAAE,EAAqB;AACjF,QAAO;EACH,MAAM;EACN,OAAO,MACI,EAAU,KAAK,IAAW,EAAS,CAAC,QAAQ;EAEvD,UAAU,EAAsB,EAAS;EAC5C"}
+{"version":3,"file":"create-generator-easing.js","names":["createGeneratorEasing","generator","createGenerator","options","scale","duration","calcGeneratorDuration","maxGeneratorDuration","progress","millisecondsToSeconds"],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs"],"sourcesContent":["import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n//# sourceMappingURL=create-generator-easing.mjs.map\n"],"ignoreList":[0],"mappings":";;;AAMA,SAASA,EAAsB,GAAS,IAAQ,KAAK,GAAiB;CAClE,IAAMC,IAAYC,EAAgB;EAAE,GAAGC;EAAS,WAAW,CAAC,GAAGC,CAAK;CAAE,CAAC,GACjEC,IAAW,KAAK,IAAIC,EAAsBL,CAAS,GAAGM,CAAoB;CAChF,OAAO;EACH,MAAM;EACN,OAAO,MACIN,EAAU,KAAKI,IAAWG,CAAQ,CAAC,CAAC,QAAQJ;EAEvD,UAAUK,EAAsBJ,CAAQ;CAC5C;AACJ"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.js

@@ -1,8 +1,7 @@
-//#region node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs
+// node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs
 function e(e) {
 	return typeof e == "function" && "applyToOptions" in e;
 }
-//#endregion
 export { e as isGenerator };
 
 //# sourceMappingURL=is-generator.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-generator.js","names":[],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs"],"sourcesContent":["function isGenerator(type) {\n    return typeof type === \"function\" && \"applyToOptions\" in type;\n}\n\nexport { isGenerator };\n//# sourceMappingURL=is-generator.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAS,EAAY,GAAM;AACvB,QAAO,OAAO,KAAS,cAAc,oBAAoB"}
+{"version":3,"file":"is-generator.js","names":["isGenerator","type"],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs"],"sourcesContent":["function isGenerator(type) {\n    return typeof type === \"function\" && \"applyToOptions\" in type;\n}\n\nexport { isGenerator };\n//# sourceMappingURL=is-generator.mjs.map\n"],"ignoreList":[0],"mappings":";AAAA,SAASA,EAAY,GAAM;CACvB,OAAO,OAAOC,KAAS,cAAc,oBAAoBA;AAC7D"}

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

@@ -1,11 +1,10 @@
 import { velocityPerSecond as e } from "../../../../../../motion-utils/dist/es/velocity-per-second.js";
-//#region node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs
+// node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs
 var t = 5;
 function n(n, r, i) {
 	let a = Math.max(r - t, 0);
 	return e(i - n(a), r - a);
 }
-//#endregion
 export { n as getGeneratorVelocity };
 
 //# sourceMappingURL=velocity.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"velocity.js","names":[],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from 'motion-utils';\n\nconst velocitySampleDuration = 5; // ms\nfunction getGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { getGeneratorVelocity };\n//# sourceMappingURL=velocity.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,IAAM,IAAyB;AAC/B,SAAS,EAAqB,GAAc,GAAG,GAAS;CACpD,IAAM,IAAQ,KAAK,IAAI,IAAI,GAAwB,EAAE;AACrD,QAAO,EAAkB,IAAU,EAAa,EAAM,EAAE,IAAI,EAAM"}
+{"version":3,"file":"velocity.js","names":["velocitySampleDuration","getGeneratorVelocity","prevT","t","velocityPerSecond","current","resolveValue"],"sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from 'motion-utils';\n\nconst velocitySampleDuration = 5; // ms\nfunction getGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { getGeneratorVelocity };\n//# sourceMappingURL=velocity.mjs.map\n"],"ignoreList":[0],"mappings":";;AAEA,IAAMA,IAAyB;AAC/B,SAASC,EAAqB,GAAc,GAAG,GAAS;CACpD,IAAMC,IAAQ,KAAK,IAAIC,IAAIH,GAAwB,CAAC;CACpD,OAAOI,EAAkBC,IAAUC,EAAaJ,CAAK,GAAGC,IAAID,CAAK;AACrE"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.js

@@ -1,17 +1,17 @@
-import { MotionGlobalConfig as e } from "../../../../../motion-utils/dist/es/global-config.js";
-import { secondsToMilliseconds as t } from "../../../../../motion-utils/dist/es/time-conversion.js";
-import { frame as n } from "../../frameloop/frame.js";
-import { getFinalKeyframe as r } from "../keyframes/get-final.js";
-import { JSAnimation as i } from "../JSAnimation.js";
+import { secondsToMilliseconds as e } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { MotionGlobalConfig as t } from "../../../../../motion-utils/dist/es/global-config.js";
+import { AsyncMotionValueAnimation as n } from "../AsyncMotionValueAnimation.js";
+import { JSAnimation as r } from "../JSAnimation.js";
+import { getValueTransition as i } from "../utils/get-value-transition.js";
 import { makeAnimationInstant as a } from "../utils/make-animation-instant.js";
-import { AsyncMotionValueAnimation as o } from "../AsyncMotionValueAnimation.js";
-import { getValueTransition as s } from "../utils/get-value-transition.js";
-import { getDefaultTransition as c } from "../utils/default-transitions.js";
-import { isTransitionDefined as l } from "../utils/is-transition-defined.js";
-//#region node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs
+import { getDefaultTransition as o } from "../utils/default-transitions.js";
+import { getFinalKeyframe as s } from "../keyframes/get-final.js";
+import { isTransitionDefined as c } from "../utils/is-transition-defined.js";
+import { frame as l } from "../../frameloop/frame.js";
+// node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs
 var u = (u, d, f, p = {}, m, h) => (g) => {
-	let _ = s(p, u) || {}, v = _.delay || p.delay || 0, { elapsed: y = 0 } = p;
-	y -= t(v);
+	let _ = i(p, u) || {}, v = _.delay || p.delay || 0, { elapsed: y = 0 } = p;
+	y -= e(v);
 	let b = {
 		keyframes: Array.isArray(f) ? f : [null, f],
 		ease: "easeOut",
@@ -28,20 +28,19 @@ var u = (u, d, f, p = {}, m, h) => (g) => {
 		motionValue: d,
 		element: h ? void 0 : m
 	};
-	l(_) || Object.assign(b, c(u, b)), b.duration &&= t(b.duration), b.repeatDelay &&= t(b.repeatDelay), b.from !== void 0 && (b.keyframes[0] = b.from);
+	c(_) || Object.assign(b, o(u, b)), b.duration &&= e(b.duration), b.repeatDelay &&= e(b.repeatDelay), b.from !== void 0 && (b.keyframes[0] = b.from);
 	let x = !1;
-	if ((b.type === !1 || b.duration === 0 && !b.repeatDelay) && (a(b), b.delay === 0 && (x = !0)), (e.instantAnimations || e.skipAnimations || m?.shouldSkipAnimations || _.skipAnimations) && (x = !0, a(b), b.delay = 0), b.allowFlatten = !_.type && !_.ease, x && !h && d.get() !== void 0) {
-		let e = r(b.keyframes, _);
+	if ((b.type === !1 || b.duration === 0 && !b.repeatDelay) && (a(b), b.delay === 0 && (x = !0)), (t.instantAnimations || t.skipAnimations || m?.shouldSkipAnimations || _.skipAnimations) && (x = !0, a(b), b.delay = 0), b.allowFlatten = !_.type && !_.ease, x && !h && d.get() !== void 0) {
+		let e = s(b.keyframes, _);
 		if (e !== void 0) {
-			n.update(() => {
+			l.update(() => {
 				b.onUpdate(e), b.onComplete();
 			});
 			return;
 		}
 	}
-	return _.isSync ? new i(b) : new o(b);
+	return _.isSync ? new r(b) : new n(b);
 };
-//#endregion
 export { u as animateMotionValue };
 
 //# sourceMappingURL=motion-value.js.map

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.js.map

@@ -1 +1 @@
-{"version":3,"file":"motion-value.js","names":[],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../keyframes/get-final.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\n     */\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations ||\n        valueTransition.skipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;AAUA,IAAM,KAAsB,GAAM,GAAO,GAAQ,IAAa,EAAE,EAAE,GAAS,OAAe,MAAe;CACrG,IAAM,IAAkB,EAAmB,GAAY,EAAK,IAAI,EAAE,EAM5D,IAAQ,EAAgB,SAAS,EAAW,SAAS,GAKvD,EAAE,aAAU,MAAM;AACtB,MAAoB,EAAsB,EAAM;CAChD,IAAM,IAAU;EACZ,WAAW,MAAM,QAAQ,EAAO,GAAG,IAAS,CAAC,MAAM,EAAO;EAC1D,MAAM;EACN,UAAU,EAAM,aAAa;EAC7B,GAAG;EACH,OAAO,CAAC;EACR,WAAW,MAAM;AAEb,GADA,EAAM,IAAI,EAAE,EACZ,EAAgB,YAAY,EAAgB,SAAS,EAAE;;EAE3D,kBAAkB;AAEd,GADA,GAAY,EACZ,EAAgB,cAAc,EAAgB,YAAY;;EAE9D;EACA,aAAa;EACb,SAAS,IAAY,KAAA,IAAY;EACpC;AAkBD,CAbK,EAAoB,EAAgB,IACrC,OAAO,OAAO,GAAS,EAAqB,GAAM,EAAQ,CAAC,EAO/D,AAAqB,EAAQ,aAAW,EAAsB,EAAQ,SAAS,EAC/E,AAAwB,EAAQ,gBAAc,EAAsB,EAAQ,YAAY,EAIpF,EAAQ,SAAS,KAAA,MACjB,EAAQ,UAAU,KAAK,EAAQ;CAEnC,IAAI,IAAa;AA0BjB,MAzBI,EAAQ,SAAS,MAChB,EAAQ,aAAa,KAAK,CAAC,EAAQ,iBACpC,EAAqB,EAAQ,EACzB,EAAQ,UAAU,MAClB,IAAa,OAGjB,EAAmB,qBACnB,EAAmB,kBACnB,GAAS,wBACT,EAAgB,oBAChB,IAAa,IACb,EAAqB,EAAQ,EAC7B,EAAQ,QAAQ,IAMpB,EAAQ,eAAe,CAAC,EAAgB,QAAQ,CAAC,EAAgB,MAM7D,KAAc,CAAC,KAAa,EAAM,KAAK,KAAK,KAAA,GAAW;EACvD,IAAM,IAAgB,EAAiB,EAAQ,WAAW,EAAgB;AAC1E,MAAI,MAAkB,KAAA,GAAW;AAC7B,KAAM,aAAa;AAEf,IADA,EAAQ,SAAS,EAAc,EAC/B,EAAQ,YAAY;KACtB;AACF;;;AAGR,QAAO,EAAgB,SACjB,IAAI,EAAY,EAAQ,GACxB,IAAI,EAA0B,EAAQ"}
+{"version":3,"file":"motion-value.js","names":["animateMotionValue","valueTransition","getValueTransition","transition","name","delay","secondsToMilliseconds","options","target","value","elapsed","v","onComplete","isHandoff","element","isTransitionDefined","getDefaultTransition","shouldSkip","makeAnimationInstant","MotionGlobalConfig","finalKeyframe","getFinalKeyframe","JSAnimation","AsyncMotionValueAnimation"],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../keyframes/get-final.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\n     */\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations ||\n        valueTransition.skipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"ignoreList":[0],"mappings":";;;;;;;;;;;AAUA,IAAMA,KAAsB,GAAM,GAAO,GAAQ,IAAa,CAAC,GAAG,GAAS,OAAe,MAAe;CACrG,IAAMC,IAAkBC,EAAmBC,GAAYC,CAAI,KAAK,CAAC,GAM3DC,IAAQJ,EAAgB,SAASE,EAAW,SAAS,GAKvD,EAAE,aAAU,MAAMA;CACtB,KAAoBG,EAAsBD,CAAK;CAC/C,IAAME,IAAU;EACZ,WAAW,MAAM,QAAQC,CAAM,IAAIA,IAAS,CAAC,MAAMA,CAAM;EACzD,MAAM;EACN,UAAUC,EAAM,YAAY;EAC5B,GAAGR;EACH,OAAO,CAACS;EACR,WAAW,MAAM;GAEb,AADAD,EAAM,IAAIE,CAAC,GACXV,EAAgB,YAAYA,EAAgB,SAASU,CAAC;EAC1D;EACA,kBAAkB;GAEd,AADAC,EAAW,GACXX,EAAgB,cAAcA,EAAgB,WAAW;EAC7D;EACA;EACA,aAAaQ;EACb,SAASI,IAAY,KAAA,IAAYC;CACrC;CAkBA,AAbKC,EAAoBd,CAAe,KACpC,OAAO,OAAOM,GAASS,EAAqBZ,GAAMG,CAAO,CAAC,GAO9D,AAAqBA,EAAQ,aAAWD,EAAsBC,EAAQ,QAAQ,GAC9E,AAAwBA,EAAQ,gBAAcD,EAAsBC,EAAQ,WAAW,GAInFA,EAAQ,SAAS,KAAA,MACjB,EAAQ,UAAU,KAAKA,EAAQ;CAEnC,IAAIU,IAAa;CA0BjB,KAzBIV,EAAQ,SAAS,MAChBA,EAAQ,aAAa,KAAK,CAACA,EAAQ,iBACpCW,EAAqBX,CAAO,GACxBA,EAAQ,UAAU,MAClB,IAAa,OAGjBY,EAAmB,qBACnBA,EAAmB,kBACnBL,GAAS,wBACTb,EAAgB,oBAChB,IAAa,IACbiB,EAAqBX,CAAO,GAC5B,EAAQ,QAAQ,IAMpB,EAAQ,eAAe,CAACN,EAAgB,QAAQ,CAACA,EAAgB,MAM7DgB,KAAc,CAACJ,KAAaJ,EAAM,IAAI,MAAM,KAAA,GAAW;EACvD,IAAMW,IAAgBC,EAAiBd,EAAQ,WAAWN,CAAe;EACzE,IAAImB,MAAkB,KAAA,GAAW;GAC7B,EAAM,aAAa;IAEf,AADAb,EAAQ,SAASa,CAAa,GAC9Bb,EAAQ,WAAW;GACvB,CAAC;GACD;EACJ;CACJ;CACA,OAAON,EAAgB,SACjB,IAAIqB,EAAYf,CAAO,IACvB,IAAIgB,EAA0BhB,CAAO;AAC/C"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.js

@@ -1,12 +1,12 @@
-import { frame as e } from "../../frameloop/frame.js";
+import { getValueTransition as e } from "../utils/get-value-transition.js";
 import { resolveTransition as t } from "../utils/resolve-transition.js";
-import { getValueTransition as n } from "../utils/get-value-transition.js";
-import { animateMotionValue as r } from "./motion-value.js";
-import { positionalKeys as i } from "../../render/utils/keys-position.js";
-import { setTarget as a } from "../../render/utils/setters.js";
-import { addValueToWillChange as o } from "../../value/will-change/add-will-change.js";
-import { getOptimisedAppearId as s } from "../optimized-appear/get-appear-id.js";
-//#region node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs
+import { positionalKeys as n } from "../../render/utils/keys-position.js";
+import { setTarget as r } from "../../render/utils/setters.js";
+import { addValueToWillChange as i } from "../../value/will-change/add-will-change.js";
+import { getOptimisedAppearId as a } from "../optimized-appear/get-appear-id.js";
+import { animateMotionValue as o } from "./motion-value.js";
+import { frame as s } from "../../frameloop/frame.js";
+// node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs
 function c({ protectedKeys: e, needsAnimating: t }, n) {
 	let r = e.hasOwnProperty(n) && t[n] !== !0;
 	return t[n] = !1, r;
@@ -19,41 +19,40 @@ function l(l, u, { delay: d = 0, transitionOverride: f, type: p } = {}) {
 	let b = [], x = p && l.animationState && l.animationState.getState()[p], S = m?.path;
 	S && S.animateVisualElement(l, g, m, d, b);
 	for (let t in g) {
-		let a = l.getValue(t, l.latestValues[t] ?? null), u = g[t];
+		let r = l.getValue(t, l.latestValues[t] ?? null), u = g[t];
 		if (u === void 0 || x && c(x, t)) continue;
 		let f = {
 			delay: d,
-			...n(m || {}, t)
+			...e(m || {}, t)
 		};
 		y && (f.skipAnimations = !0);
-		let p = a.get();
-		if (p !== void 0 && !a.isAnimating() && !Array.isArray(u) && u === p && !f.velocity) {
-			e.update(() => a.set(u));
+		let p = r.get();
+		if (p !== void 0 && !r.isAnimating() && !Array.isArray(u) && u === p && !f.velocity) {
+			s.update(() => r.set(u));
 			continue;
 		}
 		let h = !1;
 		if (window.MotionHandoffAnimation) {
-			let n = s(l);
-			if (n) {
-				let r = window.MotionHandoffAnimation(n, t, e);
-				r !== null && (f.startTime = r, h = !0);
+			let e = a(l);
+			if (e) {
+				let n = window.MotionHandoffAnimation(e, t, s);
+				n !== null && (f.startTime = n, h = !0);
 			}
 		}
-		o(l, t);
+		i(l, t);
 		let _ = v ?? l.shouldReduceMotion;
-		a.start(r(t, a, u, _ && i.has(t) ? { type: !1 } : f, l, h));
-		let S = a.animation;
+		r.start(o(t, r, u, _ && n.has(t) ? { type: !1 } : f, l, h));
+		let S = r.animation;
 		S && b.push(S);
 	}
 	if (h) {
-		let t = () => e.update(() => {
-			h && a(l, h);
+		let e = () => s.update(() => {
+			h && r(l, h);
 		});
-		b.length ? Promise.all(b).then(t) : t();
+		b.length ? Promise.all(b).then(e) : e();
 	}
 	return b;
 }
-//#endregion
 export { l as animateTarget };
 
 //# sourceMappingURL=visual-element-target.js.map

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-element-target.js","names":[],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["import { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { resolveTransition } from '../utils/resolve-transition.mjs';\nimport { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/will-change/add-will-change.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    let { transition, transitionEnd, ...target } = targetAndTransition;\n    const defaultTransition = visualElement.getDefaultTransition();\n    transition = transition\n        ? resolveTransition(transition, defaultTransition)\n        : defaultTransition;\n    const reduceMotion = transition?.reduceMotion;\n    const skipAnimations = transition?.skipAnimations;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    const path = transition?.path;\n    if (path) {\n        // path mutates `target` to claim x/y; loop below skips them.\n        path.animateVisualElement(visualElement, target, transition, delay, animations);\n    }\n    for (const key in target) {\n        const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        if (skipAnimations)\n            valueTransition.skipAnimations = true;\n        /**\n         * If the value is already at the defined target, skip the animation.\n         * We still re-assert the value via frame.update to take precedence\n         * over any stale transitionEnd callbacks from previous animations.\n         */\n        const currentValue = value.get();\n        if (currentValue !== undefined &&\n            !value.isAnimating() &&\n            !Array.isArray(valueTarget) &&\n            valueTarget === currentValue &&\n            !valueTransition.velocity) {\n            frame.update(() => value.set(valueTarget));\n            continue;\n        }\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        addValueToWillChange(visualElement, key);\n        const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;\n        value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        const applyTransitionEnd = () => frame.update(() => {\n            transitionEnd && setTarget(visualElement, transitionEnd);\n        });\n        if (animations.length) {\n            Promise.all(animations).then(applyTransitionEnd);\n        }\n        else {\n            applyTransitionEnd();\n        }\n    }\n    return animations;\n}\n\nexport { animateTarget };\n//# sourceMappingURL=visual-element-target.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;AAeA,SAAS,EAAqB,EAAE,kBAAe,qBAAkB,GAAK;CAClE,IAAM,IAAc,EAAc,eAAe,EAAI,IAAI,EAAe,OAAS;AAEjF,QADA,EAAe,KAAO,IACf;;AAEX,SAAS,EAAc,GAAe,GAAqB,EAAE,WAAQ,GAAG,uBAAoB,YAAS,EAAE,EAAE;CACrG,IAAI,EAAE,eAAY,kBAAe,GAAG,MAAW,GACzC,IAAoB,EAAc,sBAAsB;AAC9D,KAAa,IACP,EAAkB,GAAY,EAAkB,GAChD;CACN,IAAM,IAAe,GAAY,cAC3B,IAAiB,GAAY;AACnC,CAAI,MACA,IAAa;CACjB,IAAM,IAAa,EAAE,EACf,IAAqB,KACvB,EAAc,kBACd,EAAc,eAAe,UAAU,CAAC,IACtC,IAAO,GAAY;AACzB,CAAI,KAEA,EAAK,qBAAqB,GAAe,GAAQ,GAAY,GAAO,EAAW;AAEnF,MAAK,IAAM,KAAO,GAAQ;EACtB,IAAM,IAAQ,EAAc,SAAS,GAAK,EAAc,aAAa,MAAQ,KAAK,EAC5E,IAAc,EAAO;AAC3B,MAAI,MAAgB,KAAA,KACf,KACG,EAAqB,GAAoB,EAAI,CACjD;EAEJ,IAAM,IAAkB;GACpB;GACA,GAAG,EAAmB,KAAc,EAAE,EAAE,EAAI;GAC/C;AACD,EAAI,MACA,EAAgB,iBAAiB;EAMrC,IAAM,IAAe,EAAM,KAAK;AAChC,MAAI,MAAiB,KAAA,KACjB,CAAC,EAAM,aAAa,IACpB,CAAC,MAAM,QAAQ,EAAY,IAC3B,MAAgB,KAChB,CAAC,EAAgB,UAAU;AAC3B,KAAM,aAAa,EAAM,IAAI,EAAY,CAAC;AAC1C;;EAMJ,IAAI,IAAY;AAChB,MAAI,OAAO,wBAAwB;GAC/B,IAAM,IAAW,EAAqB,EAAc;AACpD,OAAI,GAAU;IACV,IAAM,IAAY,OAAO,uBAAuB,GAAU,GAAK,EAAM;AACrE,IAAI,MAAc,SACd,EAAgB,YAAY,GAC5B,IAAY;;;AAIxB,IAAqB,GAAe,EAAI;EACxC,IAAM,IAAqB,KAAgB,EAAc;AACzD,IAAM,MAAM,EAAmB,GAAK,GAAO,GAAa,KAAsB,EAAe,IAAI,EAAI,GAC/F,EAAE,MAAM,IAAO,GACf,GAAiB,GAAe,EAAU,CAAC;EACjD,IAAM,IAAY,EAAM;AACxB,EAAI,KACA,EAAW,KAAK,EAAU;;AAGlC,KAAI,GAAe;EACf,IAAM,UAA2B,EAAM,aAAa;AAChD,QAAiB,EAAU,GAAe,EAAc;IAC1D;AACF,EAAI,EAAW,SACX,QAAQ,IAAI,EAAW,CAAC,KAAK,EAAmB,GAGhD,GAAoB;;AAG5B,QAAO"}
+{"version":3,"file":"visual-element-target.js","names":["shouldBlockAnimation","shouldBlock","protectedKeys","key","needsAnimating","animateTarget","target","targetAndTransition","defaultTransition","visualElement","transition","resolveTransition","reduceMotion","skipAnimations","transitionOverride","animations","animationTypeState","type","path","delay","value","valueTarget","valueTransition","getValueTransition","currentValue","isHandoff","appearId","getOptimisedAppearId","startTime","frame","shouldReduceMotion","animateMotionValue","positionalKeys","animation","transitionEnd","applyTransitionEnd","setTarget"],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["import { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { resolveTransition } from '../utils/resolve-transition.mjs';\nimport { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/will-change/add-will-change.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    let { transition, transitionEnd, ...target } = targetAndTransition;\n    const defaultTransition = visualElement.getDefaultTransition();\n    transition = transition\n        ? resolveTransition(transition, defaultTransition)\n        : defaultTransition;\n    const reduceMotion = transition?.reduceMotion;\n    const skipAnimations = transition?.skipAnimations;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    const path = transition?.path;\n    if (path) {\n        // path mutates `target` to claim x/y; loop below skips them.\n        path.animateVisualElement(visualElement, target, transition, delay, animations);\n    }\n    for (const key in target) {\n        const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        if (skipAnimations)\n            valueTransition.skipAnimations = true;\n        /**\n         * If the value is already at the defined target, skip the animation.\n         * We still re-assert the value via frame.update to take precedence\n         * over any stale transitionEnd callbacks from previous animations.\n         */\n        const currentValue = value.get();\n        if (currentValue !== undefined &&\n            !value.isAnimating() &&\n            !Array.isArray(valueTarget) &&\n            valueTarget === currentValue &&\n            !valueTransition.velocity) {\n            frame.update(() => value.set(valueTarget));\n            continue;\n        }\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        addValueToWillChange(visualElement, key);\n        const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;\n        value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        const applyTransitionEnd = () => frame.update(() => {\n            transitionEnd && setTarget(visualElement, transitionEnd);\n        });\n        if (animations.length) {\n            Promise.all(animations).then(applyTransitionEnd);\n        }\n        else {\n            applyTransitionEnd();\n        }\n    }\n    return animations;\n}\n\nexport { animateTarget };\n//# sourceMappingURL=visual-element-target.mjs.map\n"],"ignoreList":[0],"mappings":";;;;;;;;;AAeA,SAASA,EAAqB,EAAE,kBAAe,qBAAkB,GAAK;CAClE,IAAMC,IAAcC,EAAc,eAAeC,CAAG,KAAKC,EAAeD,OAAS;CAEjF,OADA,EAAeA,KAAO,IACfF;AACX;AACA,SAASI,EAAc,GAAe,GAAqB,EAAE,WAAQ,GAAG,uBAAoB,YAAS,CAAC,GAAG;CACrG,IAAI,EAAE,eAAY,kBAAe,GAAGC,MAAWC,GACzCC,IAAoBC,EAAc,qBAAqB;CAC7D,IAAaC,IACPC,EAAkBD,GAAYF,CAAiB,IAC/CA;CACN,IAAMI,IAAeF,GAAY,cAC3BG,IAAiBH,GAAY;CACnC,AAAII,MACA,IAAaA;CACjB,IAAMC,IAAa,CAAC,GACdC,IAAqBC,KACvBR,EAAc,kBACdA,EAAc,eAAe,SAAS,CAAC,CAACQ,IACtCC,IAAOR,GAAY;CACzB,AAAIQ,KAEAA,EAAK,qBAAqBT,GAAeH,GAAQI,GAAYS,GAAOJ,CAAU;CAElF,KAAK,IAAMZ,KAAOG,GAAQ;EACtB,IAAMc,IAAQX,EAAc,SAASN,GAAKM,EAAc,aAAaN,MAAQ,IAAI,GAC3EkB,IAAcf,EAAOH;EAC3B,IAAIkB,MAAgB,KAAA,KACfL,KACGhB,EAAqBgB,GAAoBb,CAAG,GAChD;EAEJ,IAAMmB,IAAkB;GACpB;GACA,GAAGC,EAAmBb,KAAc,CAAC,GAAGP,CAAG;EAC/C;EACA,AAAIU,MACA,EAAgB,iBAAiB;EAMrC,IAAMW,IAAeJ,EAAM,IAAI;EAC/B,IAAII,MAAiB,KAAA,KACjB,CAACJ,EAAM,YAAY,KACnB,CAAC,MAAM,QAAQC,CAAW,KAC1BA,MAAgBG,KAChB,CAACF,EAAgB,UAAU;GAC3B,EAAM,aAAaF,EAAM,IAAIC,CAAW,CAAC;GACzC;EACJ;EAKA,IAAII,IAAY;EAChB,IAAI,OAAO,wBAAwB;GAC/B,IAAMC,IAAWC,EAAqBlB,CAAa;GACnD,IAAIiB,GAAU;IACV,IAAME,IAAY,OAAO,uBAAuBF,GAAUvB,GAAK0B,CAAK;IACpE,AAAID,MAAc,SACd,EAAgB,YAAYA,GAC5B,IAAY;GAEpB;EACJ;EACA,EAAqBnB,GAAeN,CAAG;EACvC,IAAM2B,IAAqBlB,KAAgBH,EAAc;EACzD,EAAM,MAAMsB,EAAmB5B,GAAKiB,GAAOC,GAAaS,KAAsBE,EAAe,IAAI7B,CAAG,IAC9F,EAAE,MAAM,GAAM,IACdmB,GAAiBb,GAAegB,CAAS,CAAC;EAChD,IAAMQ,IAAYb,EAAM;EACxB,AAAIa,KACAlB,EAAW,KAAKkB,CAAS;CAEjC;CACA,IAAIC,GAAe;EACf,IAAMC,UAA2BN,EAAM,aAAa;GAChD,KAAiBO,EAAU3B,GAAeyB,CAAa;EAC3D,CAAC;EACD,AAAInB,EAAW,SACX,QAAQ,IAAIA,CAAU,CAAC,CAAC,KAAKoB,CAAkB,IAG/CA,EAAmB;CAE3B;CACA,OAAOpB;AACX"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.js

@@ -1,28 +1,28 @@
-import { calcChildStagger as e } from "../utils/calc-child-stagger.js";
-import { resolveVariant as t } from "../../render/utils/resolve-dynamic-variants.js";
+import { resolveVariant as e } from "../../render/utils/resolve-dynamic-variants.js";
+import { calcChildStagger as t } from "../utils/calc-child-stagger.js";
 import { animateTarget as n } from "./visual-element-target.js";
-//#region node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs
-function r(e, r, a = {}) {
-	let o = t(e, r, a.type === "exit" ? e.presenceContext?.custom : void 0), { transition: s = e.getDefaultTransition() || {} } = o || {};
+// node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs
+function r(t, r, a = {}) {
+	let o = e(t, r, a.type === "exit" ? t.presenceContext?.custom : void 0), { transition: s = t.getDefaultTransition() || {} } = o || {};
 	a.transitionOverride && (s = a.transitionOverride);
-	let c = o ? () => Promise.all(n(e, o, a)) : () => Promise.resolve(), l = e.variantChildren && e.variantChildren.size ? (t = 0) => {
+	let c = o ? () => Promise.all(n(t, o, a)) : () => Promise.resolve(), l = t.variantChildren && t.variantChildren.size ? (e = 0) => {
 		let { delayChildren: n = 0, staggerChildren: o, staggerDirection: c } = s;
-		return i(e, r, t, n, o, c, a);
+		return i(t, r, e, n, o, c, a);
 	} : () => Promise.resolve(), { when: u } = s;
 	if (u) {
 		let [e, t] = u === "beforeChildren" ? [c, l] : [l, c];
 		return e().then(() => t());
-	} else return Promise.all([c(), l(a.delay)]);
+	}
+	return Promise.all([c(), l(a.delay)]);
 }
-function i(t, n, i = 0, a = 0, o = 0, s = 1, c) {
+function i(e, n, i = 0, a = 0, o = 0, s = 1, c) {
 	let l = [];
-	for (let u of t.variantChildren) u.notify("AnimationStart", n), l.push(r(u, n, {
+	for (let u of e.variantChildren) u.notify("AnimationStart", n), l.push(r(u, n, {
 		...c,
-		delay: i + (typeof a == "function" ? 0 : a) + e(t.variantChildren, u, a, o, s)
+		delay: i + (typeof a == "function" ? 0 : a) + t(e.variantChildren, u, a, o, s)
 	}).then(() => u.notify("AnimationComplete", n)));
 	return Promise.all(l);
 }
-//#endregion
 export { r as animateVariant };
 
 //# sourceMappingURL=visual-element-variant.js.map

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-element-variant.js","names":[],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { calcChildStagger } from '../utils/calc-child-stagger.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? visualElement.presenceContext?.custom\n        : undefined);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    for (const child of visualElement.variantChildren) {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delay +\n                (typeof delayChildren === \"function\" ? 0 : delayChildren) +\n                calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    }\n    return Promise.all(animations);\n}\n\nexport { animateVariant };\n//# sourceMappingURL=visual-element-variant.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,SAAS,EAAe,GAAe,GAAS,IAAU,EAAE,EAAE;CAC1D,IAAM,IAAW,EAAe,GAAe,GAAS,EAAQ,SAAS,SACnE,EAAc,iBAAiB,SAC/B,KAAA,EAAU,EACZ,EAAE,gBAAa,EAAc,sBAAsB,IAAI,EAAE,KAAK,KAAY,EAAE;AAChF,CAAI,EAAQ,uBACR,IAAa,EAAQ;CAMzB,IAAM,IAAe,UACT,QAAQ,IAAI,EAAc,GAAe,GAAU,EAAQ,CAAC,SAC5D,QAAQ,SAAS,EAKvB,IAAqB,EAAc,mBAAmB,EAAc,gBAAgB,QACnF,IAAe,MAAM;EACpB,IAAM,EAAE,mBAAgB,GAAG,oBAAiB,wBAAsB;AAClE,SAAO,EAAgB,GAAe,GAAS,GAAc,GAAe,GAAiB,GAAkB,EAAQ;WAEnH,QAAQ,SAAS,EAKvB,EAAE,YAAS;AACjB,KAAI,GAAM;EACN,IAAM,CAAC,GAAO,KAAQ,MAAS,mBACzB,CAAC,GAAc,EAAmB,GAClC,CAAC,GAAoB,EAAa;AACxC,SAAO,GAAO,CAAC,WAAW,GAAM,CAAC;OAGjC,QAAO,QAAQ,IAAI,CAAC,GAAc,EAAE,EAAmB,EAAQ,MAAM,CAAC,CAAC;;AAG/E,SAAS,EAAgB,GAAe,GAAS,IAAQ,GAAG,IAAgB,GAAG,IAAkB,GAAG,IAAmB,GAAG,GAAS;CAC/H,IAAM,IAAa,EAAE;AACrB,MAAK,IAAM,KAAS,EAAc,gBAE9B,CADA,EAAM,OAAO,kBAAkB,EAAQ,EACvC,EAAW,KAAK,EAAe,GAAO,GAAS;EAC3C,GAAG;EACH,OAAO,KACF,OAAO,KAAkB,aAAa,IAAI,KAC3C,EAAiB,EAAc,iBAAiB,GAAO,GAAe,GAAiB,EAAiB;EAC/G,CAAC,CAAC,WAAW,EAAM,OAAO,qBAAqB,EAAQ,CAAC,CAAC;AAE9D,QAAO,QAAQ,IAAI,EAAW"}
+{"version":3,"file":"visual-element-variant.js","names":["animateVariant","resolved","resolveVariant","visualElement","variant","options","getAnimation","animateTarget","getChildAnimations","transition","animateChildren","forwardDelay","delayChildren","staggerChildren","staggerDirection","when","first","last","animations","child","delay","calcChildStagger"],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { calcChildStagger } from '../utils/calc-child-stagger.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? visualElement.presenceContext?.custom\n        : undefined);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    for (const child of visualElement.variantChildren) {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delay +\n                (typeof delayChildren === \"function\" ? 0 : delayChildren) +\n                calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    }\n    return Promise.all(animations);\n}\n\nexport { animateVariant };\n//# sourceMappingURL=visual-element-variant.mjs.map\n"],"ignoreList":[0],"mappings":";;;;AAIA,SAASA,EAAe,GAAe,GAAS,IAAU,CAAC,GAAG;CAC1D,IAAMC,IAAWC,EAAeC,GAAeC,GAASC,EAAQ,SAAS,SACnEF,EAAc,iBAAiB,SAC/B,KAAA,CAAS,GACX,EAAE,gBAAaA,EAAc,qBAAqB,KAAK,CAAC,MAAMF,KAAY,CAAC;CAC/E,AAAII,EAAQ,uBACR,IAAaA,EAAQ;CAMzB,IAAMC,IAAeL,UACT,QAAQ,IAAIM,EAAcJ,GAAeF,GAAUI,CAAO,CAAC,UAC3D,QAAQ,QAAQ,GAKtBG,IAAqBL,EAAc,mBAAmBA,EAAc,gBAAgB,QACnF,IAAe,MAAM;EACpB,IAAM,EAAE,mBAAgB,GAAG,oBAAiB,wBAAsBM;EAClE,OAAOC,EAAgBP,GAAeC,GAASO,GAAcC,GAAeC,GAAiBC,GAAkBT,CAAO;CAC1H,UACQ,QAAQ,QAAQ,GAKtB,EAAE,YAASI;CACjB,IAAIM,GAAM;EACN,IAAM,CAACC,GAAOC,KAAQF,MAAS,mBACzB,CAACT,GAAcE,CAAkB,IACjC,CAACA,GAAoBF,CAAY;EACvC,OAAOU,EAAM,CAAC,CAAC,WAAWC,EAAK,CAAC;CACpC;CAEI,OAAO,QAAQ,IAAI,CAACX,EAAa,GAAGE,EAAmBH,EAAQ,KAAK,CAAC,CAAC;AAE9E;AACA,SAASK,EAAgB,GAAe,GAAS,IAAQ,GAAG,IAAgB,GAAG,IAAkB,GAAG,IAAmB,GAAG,GAAS;CAC/H,IAAMQ,IAAa,CAAC;CACpB,KAAK,IAAMC,KAAShB,EAAc,iBAE9B,AADAgB,EAAM,OAAO,kBAAkBf,CAAO,GACtCc,EAAW,KAAKlB,EAAemB,GAAOf,GAAS;EAC3C,GAAGC;EACH,OAAOe,KACF,OAAOR,KAAkB,aAAa,IAAIA,KAC3CS,EAAiBlB,EAAc,iBAAiBgB,GAAOP,GAAeC,GAAiBC,CAAgB;CAC/G,CAAC,CAAC,CAAC,WAAWK,EAAM,OAAO,qBAAqBf,CAAO,CAAC,CAAC;CAE7D,OAAO,QAAQ,IAAIc,CAAU;AACjC"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.js

@@ -1,7 +1,7 @@
 import { resolveVariant as e } from "../../render/utils/resolve-dynamic-variants.js";
 import { animateTarget as t } from "./visual-element-target.js";
 import { animateVariant as n } from "./visual-element-variant.js";
-//#region node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs
+// node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs
 function r(r, i, a = {}) {
 	r.notify("AnimationStart", i);
 	let o;
@@ -17,7 +17,6 @@ function r(r, i, a = {}) {
 		r.notify("AnimationComplete", i);
 	});
 }
-//#endregion
 export { r as animateVisualElement };
 
 //# sourceMappingURL=visual-element.js.map

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-element.js","names":[],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        visualElement.notify(\"AnimationComplete\", definition);\n    });\n}\n\nexport { animateVisualElement };\n//# sourceMappingURL=visual-element.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,SAAS,EAAqB,GAAe,GAAY,IAAU,EAAE,EAAE;AACnE,GAAc,OAAO,kBAAkB,EAAW;CAClD,IAAI;AACJ,KAAI,MAAM,QAAQ,EAAW,EAAE;EAC3B,IAAM,IAAa,EAAW,KAAK,MAAY,EAAe,GAAe,GAAS,EAAQ,CAAC;AAC/F,MAAY,QAAQ,IAAI,EAAW;YAE9B,OAAO,KAAe,SAC3B,KAAY,EAAe,GAAe,GAAY,EAAQ;MAE7D;EACD,IAAM,IAAqB,OAAO,KAAe,aAC3C,EAAe,GAAe,GAAY,EAAQ,OAAO,GACzD;AACN,MAAY,QAAQ,IAAI,EAAc,GAAe,GAAoB,EAAQ,CAAC;;AAEtF,QAAO,EAAU,WAAW;AACxB,IAAc,OAAO,qBAAqB,EAAW;GACvD"}
+{"version":3,"file":"visual-element.js","names":["animateVisualElement","definition","animation","animations","animateVariant","visualElement","variant","options","resolvedDefinition","resolveVariant","animateTarget"],"sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        visualElement.notify(\"AnimationComplete\", definition);\n    });\n}\n\nexport { animateVisualElement };\n//# sourceMappingURL=visual-element.mjs.map\n"],"ignoreList":[0],"mappings":";;;;AAIA,SAASA,EAAqB,GAAe,GAAY,IAAU,CAAC,GAAG;CACnE,EAAc,OAAO,kBAAkBC,CAAU;CACjD,IAAIC;CACJ,IAAI,MAAM,QAAQD,CAAU,GAAG;EAC3B,IAAME,IAAaF,EAAW,KAAK,MAAYG,EAAeC,GAAeC,GAASC,CAAO,CAAC;EAC9F,IAAY,QAAQ,IAAIJ,CAAU;CACtC,OACK,IAAI,OAAOF,KAAe,UAC3B,IAAYG,EAAeC,GAAeJ,GAAYM,CAAO;MAE5D;EACD,IAAMC,IAAqB,OAAOP,KAAe,aAC3CQ,EAAeJ,GAAeJ,GAAYM,EAAQ,MAAM,IACxDN;EACN,IAAY,QAAQ,IAAIS,EAAcL,GAAeG,GAAoBD,CAAO,CAAC;CACrF;CACA,OAAOL,EAAU,WAAW;EACxB,EAAc,OAAO,qBAAqBD,CAAU;CACxD,CAAC;AACL"}