{"version":3,"file":"static/chunks/484-90586bbf2ef06b34.js","mappings":"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","sources":["webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/easing.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/ease.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/circ.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/back.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/anticipate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/map.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/time.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/inertia.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/js/driver-frameloop.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/js/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/create-accelerated-animation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/instant.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-none.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/keyframes.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/VisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/store.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix-color.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix-complex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/interpolate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/memo.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/default.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/fill.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/pipe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/progress.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/hex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/hsla.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/rgba.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/utils.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/complex/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","webpack://_N_E/<anon>"],"sourcesContent":["import { warning } from '../../../utils/errors.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { secondsToMilliseconds, millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\n\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(maxDuration), \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, 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: 100,\n            damping: 10,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };\n","import { millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    const initialVelocity = velocity ? -millisecondsToSeconds(velocity) : 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 0) {\n                    /**\n                     * We only need to calculate velocity for under-damped springs\n                     * as over- and critically-damped springs can't overshoot, so\n                     * checking only for displacement is enough.\n                     */\n                    if (dampingRatio < 1) {\n                        currentVelocity = calcGeneratorVelocity(resolveSpring, t, current);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n    };\n}\n\nexport { spring };\n","/**\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","import { velocityPerSecond } from '../../../utils/velocity-per-second.mjs';\n\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === \"number\";\n\nexport { isBezierDefinition };\n","import { isBezierDefinition } from '../../../easing/utils/is-bezier-definition.mjs';\n\nfunction isWaapiSupportedEasing(easing) {\n    return Boolean(!easing ||\n        (typeof easing === \"string\" && supportedWaapiEasing[easing]) ||\n        isBezierDefinition(easing) ||\n        (Array.isArray(easing) && easing.every(isWaapiSupportedEasing)));\n}\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\nconst supportedWaapiEasing = {\n    linear: \"linear\",\n    ease: \"ease\",\n    easeIn: \"ease-in\",\n    easeOut: \"ease-out\",\n    easeInOut: \"ease-in-out\",\n    circIn: cubicBezierAsString([0, 0.65, 0.55, 1]),\n    circOut: cubicBezierAsString([0.55, 0, 1, 0.45]),\n    backIn: cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n    backOut: cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),\n};\nfunction mapEasingToNativeEasing(easing) {\n    if (!easing)\n        return undefined;\n    return isBezierDefinition(easing)\n        ? cubicBezierAsString(easing)\n        : Array.isArray(easing)\n            ? easing.map(mapEasingToNativeEasing)\n            : supportedWaapiEasing[easing];\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","import { mapEasingToNativeEasing } from './easing.mjs';\n\nfunction animateStyle(element, valueName, keyframes, { delay = 0, duration, repeat = 0, repeatType = \"loop\", ease, times, } = {}) {\n    const keyframeOptions = { [valueName]: keyframes };\n    if (times)\n        keyframeOptions.offset = times;\n    const easing = mapEasingToNativeEasing(ease);\n    /**\n     * If this is an easing array, apply to keyframes, not animation as a whole\n     */\n    if (Array.isArray(easing))\n        keyframeOptions.easing = easing;\n    return element.animate(keyframeOptions, {\n        delay,\n        duration,\n        easing: !Array.isArray(easing) ? easing : \"linear\",\n        fill: \"both\",\n        iterations: repeat + 1,\n        direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\",\n    });\n}\n\nexport { animateStyle };\n","function getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }) {\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : keyframes.length - 1;\n    return keyframes[index];\n}\n\nexport { getFinalKeyframe };\n","import { noop } from '../utils/noop.mjs';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { cubicBezier } from './cubic-bezier.mjs';\n\nconst easeIn = cubicBezier(0.42, 0, 1, 1);\nconst easeOut = cubicBezier(0, 0, 0.58, 1);\nconst easeInOut = cubicBezier(0.42, 0, 0.58, 1);\n\nexport { easeIn, easeInOut, easeOut };\n","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\n\nexport { circIn, circInOut, circOut };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = reverseEasing(backOut);\nconst backInOut = mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","import { invariant } from '../../utils/errors.mjs';\nimport { cubicBezier } from '../cubic-bezier.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { easeIn, easeInOut, easeOut } from '../ease.mjs';\nimport { circIn, circInOut, circOut } from '../circ.mjs';\nimport { backIn, backInOut, backOut } from '../back.mjs';\nimport { anticipate } from '../anticipate.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n        const [x1, y1, x2, y2] = definition;\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);\n        return easingLookup[definition];\n    }\n    return definition;\n};\n\nexport { easingDefinitionToFunction };\n","function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n","import { easeInOut } from '../../easing/ease.mjs';\nimport { isEasingArray } from '../../easing/utils/is-easing-array.mjs';\nimport { easingDefinitionToFunction } from '../../easing/utils/map.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n","import { spring } from './spring/index.mjs';\nimport { calcGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: calcGeneratorVelocity(calcLatest, t, state.value),\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t > timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n","import { frame, cancelFrame, frameData } from '../../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: () => frame.update(passTimestamp, true),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => frameData.isProcessing ? frameData.timestamp : performance.now(),\n    };\n};\n\nexport { frameloopDriver };\n","import { keyframes } from '../../generators/keyframes.mjs';\nimport { spring } from '../../generators/spring/index.mjs';\nimport { inertia } from '../../generators/inertia.mjs';\nimport { frameloopDriver } from './driver-frameloop.mjs';\nimport { interpolate } from '../../../utils/interpolate.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorDuration } from '../../generators/utils/calc-duration.mjs';\n\nconst types = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\n/**\n * Animate a single value on the main thread.\n *\n * This function is written, where functionality overlaps,\n * to be largely spec-compliant with WAAPI to allow fungibility\n * between the two.\n */\nfunction animateValue({ autoplay = true, delay = 0, driver = frameloopDriver, keyframes: keyframes$1, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", onPlay, onStop, onComplete, onUpdate, ...options }) {\n    let speed = 1;\n    let hasStopped = false;\n    let resolveFinishedPromise;\n    let currentFinishedPromise;\n    /**\n     * Resolve the current Promise every time we enter the\n     * finished state. This is WAAPI-compatible behaviour.\n     */\n    const updateFinishedPromise = () => {\n        currentFinishedPromise = new Promise((resolve) => {\n            resolveFinishedPromise = resolve;\n        });\n    };\n    // Create the first finished promise\n    updateFinishedPromise();\n    let animationDriver;\n    const generatorFactory = types[type] || keyframes;\n    /**\n     * If this isn't the keyframes generator and we've been provided\n     * strings as keyframes, we need to interpolate these.\n     * TODO: Support velocity for units and complex value types/\n     */\n    let mapNumbersToKeyframes;\n    if (generatorFactory !== keyframes &&\n        typeof keyframes$1[0] !== \"number\") {\n        mapNumbersToKeyframes = interpolate([0, 100], keyframes$1, {\n            clamp: false,\n        });\n        keyframes$1 = [0, 100];\n    }\n    const generator = generatorFactory({ ...options, keyframes: keyframes$1 });\n    let mirroredGenerator;\n    if (repeatType === \"mirror\") {\n        mirroredGenerator = generatorFactory({\n            ...options,\n            keyframes: [...keyframes$1].reverse(),\n            velocity: -(options.velocity || 0),\n        });\n    }\n    let playState = \"idle\";\n    let holdTime = null;\n    let startTime = null;\n    let cancelTime = null;\n    /**\n     * If duration is undefined and we have repeat options,\n     * we need to calculate a duration from the generator.\n     *\n     * We set it to the generator itself to cache the duration.\n     * Any timeline resolver will need to have already precalculated\n     * the duration by this step.\n     */\n    if (generator.calculatedDuration === null && repeat) {\n        generator.calculatedDuration = calcGeneratorDuration(generator);\n    }\n    const { calculatedDuration } = generator;\n    let resolvedDuration = Infinity;\n    let totalDuration = Infinity;\n    if (calculatedDuration !== null) {\n        resolvedDuration = calculatedDuration + repeatDelay;\n        totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n    }\n    let currentTime = 0;\n    const tick = (timestamp) => {\n        if (startTime === null)\n            return;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (speed > 0)\n            startTime = Math.min(startTime, timestamp);\n        if (speed < 0)\n            startTime = Math.min(timestamp - totalDuration / speed, startTime);\n        if (holdTime !== null) {\n            currentTime = holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            currentTime = Math.round(timestamp - startTime) * speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = currentTime - delay * (speed >= 0 ? 1 : -1);\n        const isInDelayPhase = speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;\n        currentTime = Math.max(timeWithoutDelay, 0);\n        /**\n         * If this animation has finished, set the current time\n         * to the total duration.\n         */\n        if (playState === \"finished\" && holdTime === null) {\n            currentTime = totalDuration;\n        }\n        let elapsed = currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = currentTime / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const iterationIsOdd = Boolean(currentIteration % 2);\n            if (iterationIsOdd) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            let p = clamp(0, 1, iterationProgress);\n            if (currentTime > totalDuration) {\n                p = repeatType === \"reverse\" && iterationIsOdd ? 1 : 0;\n            }\n            elapsed = p * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        const state = isInDelayPhase\n            ? { done: false, value: keyframes$1[0] }\n            : frameGenerator.next(elapsed);\n        if (mapNumbersToKeyframes) {\n            state.value = mapNumbersToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done = speed >= 0 ? currentTime >= totalDuration : currentTime <= 0;\n        }\n        const isAnimationFinished = holdTime === null &&\n            (playState === \"finished\" || (playState === \"running\" && done));\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            finish();\n        }\n        return state;\n    };\n    const stopAnimationDriver = () => {\n        animationDriver && animationDriver.stop();\n        animationDriver = undefined;\n    };\n    const cancel = () => {\n        playState = \"idle\";\n        stopAnimationDriver();\n        resolveFinishedPromise();\n        updateFinishedPromise();\n        startTime = cancelTime = null;\n    };\n    const finish = () => {\n        playState = \"finished\";\n        onComplete && onComplete();\n        stopAnimationDriver();\n        resolveFinishedPromise();\n    };\n    const play = () => {\n        if (hasStopped)\n            return;\n        if (!animationDriver)\n            animationDriver = driver(tick);\n        const now = animationDriver.now();\n        onPlay && onPlay();\n        if (holdTime !== null) {\n            startTime = now - holdTime;\n        }\n        else if (!startTime || playState === \"finished\") {\n            startTime = now;\n        }\n        if (playState === \"finished\") {\n            updateFinishedPromise();\n        }\n        cancelTime = startTime;\n        holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        playState = \"running\";\n        animationDriver.start();\n    };\n    if (autoplay) {\n        play();\n    }\n    const controls = {\n        then(resolve, reject) {\n            return currentFinishedPromise.then(resolve, reject);\n        },\n        get time() {\n            return millisecondsToSeconds(currentTime);\n        },\n        set time(newTime) {\n            newTime = secondsToMilliseconds(newTime);\n            currentTime = newTime;\n            if (holdTime !== null || !animationDriver || speed === 0) {\n                holdTime = newTime;\n            }\n            else {\n                startTime = animationDriver.now() - newTime / speed;\n            }\n        },\n        get duration() {\n            const duration = generator.calculatedDuration === null\n                ? calcGeneratorDuration(generator)\n                : generator.calculatedDuration;\n            return millisecondsToSeconds(duration);\n        },\n        get speed() {\n            return speed;\n        },\n        set speed(newSpeed) {\n            if (newSpeed === speed || !animationDriver)\n                return;\n            speed = newSpeed;\n            controls.time = millisecondsToSeconds(currentTime);\n        },\n        get state() {\n            return playState;\n        },\n        play,\n        pause: () => {\n            playState = \"paused\";\n            holdTime = currentTime;\n        },\n        stop: () => {\n            hasStopped = true;\n            if (playState === \"idle\")\n                return;\n            playState = \"idle\";\n            onStop && onStop();\n            cancel();\n        },\n        cancel: () => {\n            if (cancelTime !== null)\n                tick(cancelTime);\n            cancel();\n        },\n        complete: () => {\n            playState = \"finished\";\n        },\n        sample: (elapsed) => {\n            startTime = 0;\n            return tick(elapsed);\n        },\n    };\n    return controls;\n}\n\nexport { animateValue };\n","import { animateStyle } from './index.mjs';\nimport { isWaapiSupportedEasing } from './easing.mjs';\nimport { getFinalKeyframe } from './utils/get-final-keyframe.mjs';\nimport { animateValue } from '../js/index.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../../utils/time-conversion.mjs';\nimport { memo } from '../../../utils/memo.mjs';\nimport { noop } from '../../../utils/noop.mjs';\nimport { frameData, frame, cancelFrame } from '../../../frameloop/frame.mjs';\n\nconst supportsWaapi = memo(() => Object.hasOwnProperty.call(Element.prototype, \"animate\"));\n/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\n    \"opacity\",\n    \"clipPath\",\n    \"filter\",\n    \"transform\",\n    \"backgroundColor\",\n]);\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxDuration = 20000;\nconst requiresPregeneratedKeyframes = (valueName, options) => options.type === \"spring\" ||\n    valueName === \"backgroundColor\" ||\n    !isWaapiSupportedEasing(options.ease);\nfunction createAcceleratedAnimation(value, valueName, { onUpdate, onComplete, ...options }) {\n    const canAccelerateAnimation = supportsWaapi() &&\n        acceleratedValues.has(valueName) &&\n        !options.repeatDelay &&\n        options.repeatType !== \"mirror\" &&\n        options.damping !== 0 &&\n        options.type !== \"inertia\";\n    if (!canAccelerateAnimation)\n        return false;\n    /**\n     * TODO: Unify with js/index\n     */\n    let hasStopped = false;\n    let resolveFinishedPromise;\n    let currentFinishedPromise;\n    /**\n     * Resolve the current Promise every time we enter the\n     * finished state. This is WAAPI-compatible behaviour.\n     */\n    const updateFinishedPromise = () => {\n        currentFinishedPromise = new Promise((resolve) => {\n            resolveFinishedPromise = resolve;\n        });\n    };\n    // Create the first finished promise\n    updateFinishedPromise();\n    let { keyframes, duration = 300, ease, times } = options;\n    /**\n     * If this animation needs pre-generated keyframes then generate.\n     */\n    if (requiresPregeneratedKeyframes(valueName, options)) {\n        const sampleAnimation = animateValue({\n            ...options,\n            repeat: 0,\n            delay: 0,\n        });\n        let state = { done: false, value: keyframes[0] };\n        const pregeneratedKeyframes = [];\n        /**\n         * Bail after 20 seconds of pre-generated keyframes as it's likely\n         * we're heading for an infinite loop.\n         */\n        let t = 0;\n        while (!state.done && t < maxDuration) {\n            state = sampleAnimation.sample(t);\n            pregeneratedKeyframes.push(state.value);\n            t += sampleDelta;\n        }\n        times = undefined;\n        keyframes = pregeneratedKeyframes;\n        duration = t - sampleDelta;\n        ease = \"linear\";\n    }\n    const animation = animateStyle(value.owner.current, valueName, keyframes, {\n        ...options,\n        duration,\n        /**\n         * This function is currently not called if ease is provided\n         * as a function so the cast is safe.\n         *\n         * However it would be possible for a future refinement to port\n         * in easing pregeneration from Motion One for browsers that\n         * support the upcoming `linear()` easing function.\n         */\n        ease: ease,\n        times,\n    });\n    /**\n     * WAAPI animations don't resolve startTime synchronously. But a blocked\n     * thread could delay the startTime resolution by a noticeable amount.\n     * For synching handoff animations with the new Motion animation we want\n     * to ensure startTime is synchronously set.\n     */\n    if (options.syncStart) {\n        animation.startTime = frameData.isProcessing\n            ? frameData.timestamp\n            : document.timeline\n                ? document.timeline.currentTime\n                : performance.now();\n    }\n    const cancelAnimation = () => animation.cancel();\n    const safeCancel = () => {\n        frame.update(cancelAnimation);\n        resolveFinishedPromise();\n        updateFinishedPromise();\n    };\n    /**\n     * Prefer the `onfinish` prop as it's more widely supported than\n     * the `finished` promise.\n     *\n     * Here, we synchronously set the provided MotionValue to the end\n     * keyframe. If we didn't, when the WAAPI animation is finished it would\n     * be removed from the element which would then revert to its old styles.\n     */\n    animation.onfinish = () => {\n        value.set(getFinalKeyframe(keyframes, options));\n        onComplete && onComplete();\n        safeCancel();\n    };\n    /**\n     * Animation interrupt callback.\n     */\n    const controls = {\n        then(resolve, reject) {\n            return currentFinishedPromise.then(resolve, reject);\n        },\n        attachTimeline(timeline) {\n            animation.timeline = timeline;\n            animation.onfinish = null;\n            return noop;\n        },\n        get time() {\n            return millisecondsToSeconds(animation.currentTime || 0);\n        },\n        set time(newTime) {\n            animation.currentTime = secondsToMilliseconds(newTime);\n        },\n        get speed() {\n            return animation.playbackRate;\n        },\n        set speed(newSpeed) {\n            animation.playbackRate = newSpeed;\n        },\n        get duration() {\n            return millisecondsToSeconds(duration);\n        },\n        play: () => {\n            if (hasStopped)\n                return;\n            animation.play();\n            /**\n             * Cancel any pending cancel tasks\n             */\n            cancelFrame(cancelAnimation);\n        },\n        pause: () => animation.pause(),\n        stop: () => {\n            hasStopped = true;\n            if (animation.playState === \"idle\")\n                return;\n            /**\n             * WAAPI doesn't natively have any interruption capabilities.\n             *\n             * Rather than read commited styles back out of the DOM, we can\n             * create a renderless JS animation and sample it twice to calculate\n             * its current value, \"previous\" value, and therefore allow\n             * Motion to calculate velocity for any subsequent animation.\n             */\n            const { currentTime } = animation;\n            if (currentTime) {\n                const sampleAnimation = animateValue({\n                    ...options,\n                    autoplay: false,\n                });\n                value.setWithVelocity(sampleAnimation.sample(currentTime - sampleDelta).value, sampleAnimation.sample(currentTime).value, sampleDelta);\n            }\n            safeCancel();\n        },\n        complete: () => animation.finish(),\n        cancel: safeCancel,\n    };\n    return controls;\n}\n\nexport { createAcceleratedAnimation };\n","import { animateValue } from './js/index.mjs';\nimport { noop } from '../../utils/noop.mjs';\n\nfunction createInstantAnimation({ keyframes, delay, onUpdate, onComplete, }) {\n    const setValue = () => {\n        onUpdate && onUpdate(keyframes[keyframes.length - 1]);\n        onComplete && onComplete();\n        /**\n         * TODO: As this API grows it could make sense to always return\n         * animateValue. This will be a bigger project as animateValue\n         * is frame-locked whereas this function resolves instantly.\n         * This is a behavioural change and also has ramifications regarding\n         * assumptions within tests.\n         */\n        return {\n            time: 0,\n            speed: 1,\n            duration: 0,\n            play: (noop),\n            pause: (noop),\n            stop: (noop),\n            then: (resolve) => {\n                resolve();\n                return Promise.resolve();\n            },\n            cancel: (noop),\n            complete: (noop),\n        };\n    };\n    return delay\n        ? animateValue({\n            keyframes: [0, 1],\n            duration: 0,\n            delay,\n            onComplete: setValue,\n        })\n        : setValue();\n}\n\nexport { createInstantAnimation };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\n\nconst underDampedSpring = {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n};\nconst criticallyDampedSpring = (target) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n    type: \"keyframes\",\n    ease: [0.25, 0.1, 0.35, 1],\n    duration: 0.3,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else if (transformProps.has(valueKey)) {\n        return valueKey.startsWith(\"scale\")\n            ? criticallyDampedSpring(keyframes[1])\n            : underDampedSpring;\n    }\n    return ease;\n};\n\nexport { getDefaultTransition };\n","import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (key, value) => {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        (complex.test(value) || value === \"0\") && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nexport { isAnimatable };\n","import { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\n\nfunction isNone(value) {\n    if (typeof value === \"number\") {\n        return value === 0;\n    }\n    else if (value !== null) {\n        return value === \"none\" || value === \"0\" || isZeroValueString(value);\n    }\n}\n\nexport { isNone };\n","import { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { isNone } from './is-none.mjs';\n\nfunction getKeyframes(value, valueName, target, transition) {\n    const isTargetAnimatable = isAnimatable(valueName, target);\n    let keyframes;\n    if (Array.isArray(target)) {\n        keyframes = [...target];\n    }\n    else {\n        keyframes = [null, target];\n    }\n    const defaultOrigin = transition.from !== undefined ? transition.from : value.get();\n    let animatableTemplateValue = undefined;\n    const noneKeyframeIndexes = [];\n    for (let i = 0; i < keyframes.length; i++) {\n        /**\n         * Fill null/wildcard keyframes\n         */\n        if (keyframes[i] === null) {\n            keyframes[i] = i === 0 ? defaultOrigin : keyframes[i - 1];\n        }\n        if (isNone(keyframes[i])) {\n            noneKeyframeIndexes.push(i);\n        }\n        // TODO: Clean this conditional, it works for now\n        if (typeof keyframes[i] === \"string\" &&\n            keyframes[i] !== \"none\" &&\n            keyframes[i] !== \"0\") {\n            animatableTemplateValue = keyframes[i];\n        }\n    }\n    if (isTargetAnimatable &&\n        noneKeyframeIndexes.length &&\n        animatableTemplateValue) {\n        for (let i = 0; i < noneKeyframeIndexes.length; i++) {\n            const index = noneKeyframeIndexes[i];\n            keyframes[index] = getAnimatableNone(valueName, animatableTemplateValue);\n        }\n    }\n    return keyframes;\n}\n\nexport { getKeyframes };\n","/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {\n    return !!Object.keys(transition).length;\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n\nexport { getValueTransition, isTransitionDefined };\n","import { warning } from '../../utils/errors.mjs';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { createAcceleratedAnimation } from '../animators/waapi/create-accelerated-animation.mjs';\nimport { createInstantAnimation } from '../animators/instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { isAnimatable } from '../utils/is-animatable.mjs';\nimport { getKeyframes } from '../utils/keyframes.mjs';\nimport { getValueTransition, isTransitionDefined } from '../utils/transitions.mjs';\nimport { animateValue } from '../animators/js/index.mjs';\n\nconst animateMotionValue = (valueName, value, target, transition = {}) => {\n    return (onComplete) => {\n        const valueTransition = getValueTransition(transition, valueName) || {};\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 keyframes = getKeyframes(value, valueName, target, valueTransition);\n        /**\n         * Check if we're able to animate between the start and end keyframes,\n         * and throw a warning if we're attempting to animate between one that's\n         * animatable and another that isn't.\n         */\n        const originKeyframe = keyframes[0];\n        const targetKeyframe = keyframes[keyframes.length - 1];\n        const isOriginAnimatable = isAnimatable(valueName, originKeyframe);\n        const isTargetAnimatable = isAnimatable(valueName, targetKeyframe);\n        warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${valueName} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n        let options = {\n            keyframes,\n            velocity: value.getVelocity(),\n            ease: \"easeOut\",\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        };\n        /**\n         * If there's no transition defined for this value, we can generate\n         * unqiue transition settings for this value.\n         */\n        if (!isTransitionDefined(valueTransition)) {\n            options = {\n                ...options,\n                ...getDefaultTransition(valueName, options),\n            };\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        if (options.duration) {\n            options.duration = secondsToMilliseconds(options.duration);\n        }\n        if (options.repeatDelay) {\n            options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n        }\n        if (!isOriginAnimatable ||\n            !isTargetAnimatable ||\n            instantAnimationState.current ||\n            valueTransition.type === false) {\n            /**\n             * If we can't animate this value, or the global instant animation flag is set,\n             * or this is simply defined as an instant transition, return an instant transition.\n             */\n            return createInstantAnimation(instantAnimationState.current\n                ? { ...options, delay: 0 }\n                : options);\n        }\n        /**\n         * Animate via WAAPI if possible.\n         */\n        if (value.owner &&\n            value.owner.current instanceof HTMLElement &&\n            !value.owner.getProps().onUpdate) {\n            const acceleratedAnimation = createAcceleratedAnimation(value, valueName, options);\n            if (acceleratedAnimation)\n                return acceleratedAnimation;\n        }\n        /**\n         * If we didn't create an accelerated animation, create a JS animation\n         */\n        return animateValue(options);\n    };\n};\n\nexport { animateMotionValue };\n","import { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';\n\nconst optimizedAppearDataId = \"framerAppearId\";\nconst optimizedAppearDataAttribute = \"data-\" + camelToDash(optimizedAppearDataId);\n\nexport { optimizedAppearDataAttribute, optimizedAppearDataId };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\nimport { optimizedAppearDataAttribute } from '../optimized-appear/data-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { setTarget } from '../../render/utils/setters.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, definition, { delay = 0, transitionOverride, type } = {}) {\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = visualElement.makeTargetAnimatable(definition);\n    const willChange = visualElement.getValue(\"willChange\");\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key);\n        const valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            elapsed: 0,\n            ...transition,\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        if (window.HandoffAppearAnimations && !value.hasAnimated) {\n            const appearId = visualElement.getProps()[optimizedAppearDataAttribute];\n            if (appearId) {\n                valueTransition.elapsed = window.HandoffAppearAnimations(appearId, key, value, frame);\n                valueTransition.syncStart = true;\n            }\n        }\n        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)\n            ? { type: false }\n            : valueTransition));\n        const animation = value.animation;\n        if (isWillChangeMotionValue(willChange)) {\n            willChange.add(key);\n            animation.then(() => willChange.remove(key));\n        }\n        animations.push(animation);\n    }\n    if (transitionEnd) {\n        Promise.all(animations).then(() => {\n            transitionEnd && setTarget(visualElement, transitionEnd);\n        });\n    }\n    return animations;\n}\n\nexport { animateTarget };\n","const isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { isEasingArray };\n","const createAxisDelta = () => ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n});\nconst createDelta = () => ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n});\nconst createAxis = () => ({ min: 0, max: 0 });\nconst createBox = () => ({\n    x: createAxis(),\n    y: createAxis(),\n});\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","import { invariant } from '../../../utils/errors.mjs';\nimport { isNumericalString } from '../../../utils/is-numerical-string.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst splitCSSVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    const match = splitCSSVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token, fallback] = match;\n    return [token, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        const trimmed = resolved.trim();\n        return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;\n    }\n    else if (isCSSVariableToken(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, { ...target }, transitionEnd) {\n    const element = visualElement.current;\n    if (!(element instanceof Element))\n        return { target, transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = { ...transitionEnd };\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.values.forEach((value) => {\n        const current = value.get();\n        if (!isCSSVariableToken(current))\n            return;\n        const resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (const key in target) {\n        const current = target[key];\n        if (!isCSSVariableToken(current))\n            continue;\n        const resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        if (!transitionEnd)\n            transitionEnd = {};\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd[key] === undefined) {\n            transitionEnd[key] = current;\n        }\n    }\n    return { target, transitionEnd };\n}\n\nexport { parseCSSVariable, resolveCSSVariables };\n","import { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from '../../../utils/errors.mjs';\nimport { transformPropOrder } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\nimport { isBrowser } from '../../../utils/is-browser.mjs';\nimport { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n    \"translateX\",\n    \"translateY\",\n]);\nconst isPositionalKey = (key) => positionalKeys.has(key);\nconst hasPositionalKey = (target) => {\n    return Object.keys(target).some(isPositionalKey);\n};\nconst isNumOrPxType = (v) => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.render();\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\n// Alias translate longform names\npositionalValues.translateX = positionalValues.x;\npositionalValues.translateY = positionalValues.y;\nconst convertChangedValueTypes = (target, visualElement, changedKeys) => {\n    const originBbox = visualElement.measureViewportBox();\n    const element = visualElement.current;\n    const elementComputedStyle = getComputedStyle(element);\n    const { display } = elementComputedStyle;\n    const origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach((key) => {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.render();\n    const targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach((key) => {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        const value = visualElement.getValue(key);\n        value && value.jump(origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nconst checkAndConvertChangedValueTypes = (visualElement, target, origin = {}, transitionEnd = {}) => {\n    target = { ...target };\n    transitionEnd = { ...transitionEnd };\n    const targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    let removedTransformValues = [];\n    let hasAttemptedToRemoveTransformValues = false;\n    const changedValueTypeKeys = [];\n    targetPositionalKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        let from = origin[key];\n        let fromType = findDimensionValueType(from);\n        const to = target[key];\n        let toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            const numKeyframes = to.length;\n            const fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (let i = fromIndex; i < numKeyframes; i++) {\n                /**\n                 * Don't allow wildcard keyframes to be used to detect\n                 * a difference in value types.\n                 */\n                if (to[i] === null)\n                    break;\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                const current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                value.jump(to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        const scrollY = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        const convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(([key, value]) => {\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.render();\n        // Restore scroll position\n        if (isBrowser && scrollY !== null) {\n            window.scrollTo({ top: scrollY });\n        }\n        return { target: convertedTarget, transitionEnd };\n    }\n    else {\n        return { target, transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target, transitionEnd };\n}\n\nexport { positionalValues, unitConversion };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nconst parseDomVariant = (visualElement, target, origin, transitionEnd) => {\n    const resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","import { isBrowser } from '../is-browser.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { initPrefersReducedMotion };\n","import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"10.16.5\", `Attempting to mix Framer Motion versions ${nextValue.version} with 10.16.5 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { warning, invariant } from '../utils/errors.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isRefObject } from '../utils/is-ref-object.mjs';\nimport { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isWillChangeMotionValue } from '../value/use-will-change/is.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { transformProps } from './html/utils/transform.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { isVariantLabel } from './utils/is-variant-label.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { variantProps } from './utils/variant-props.mjs';\nimport { visualElementStore } from './store.mjs';\nimport { frame, cancelFrame } from '../frameloop/frame.mjs';\n\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\nconst numVariantProps = variantProps.length;\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    constructor({ parent, props, presenceContext, reducedMotionConfig, visualState, }, options = {}) {\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        this.values = new Map();\n        /**\n         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.scheduleRender = () => frame.render(this.render, false, true);\n        const { latestValues, renderState } = visualState;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.presenceContext = presenceContext;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {});\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n                if (isWillChangeMotionValue(willChange)) {\n                    willChange.add(key);\n                }\n            }\n        }\n    }\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props, _prevProps) {\n        return {};\n    }\n    mount(instance) {\n        this.current = instance;\n        visualElementStore.set(instance, this);\n        if (this.projection && !this.projection.instance) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = this.parent.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        visualElementStore.delete(this.current);\n        this.projection && this.projection.unmount();\n        cancelFrame(this.notifyUpdate);\n        cancelFrame(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            this.features[key].unmount();\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate &&\n                frame.update(this.notifyUpdate, false, true);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type) {\n            return 0;\n        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    loadFeatures({ children, ...renderedProps }, isStrict, preloadedFeatures, initialLayoutGroupConfig) {\n        let ProjectionNodeConstructor;\n        let MeasureLayout;\n        /**\n         * If we're in development mode, check to make sure we're not rendering a motion component\n         * as a child of LazyMotion, as this will break the file-size benefits of using it.\n         */\n        if (process.env.NODE_ENV !== \"production\" &&\n            preloadedFeatures &&\n            isStrict) {\n            const strictMessage = \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\";\n            renderedProps.ignoreStrict\n                ? warning(false, strictMessage)\n                : invariant(false, strictMessage);\n        }\n        for (let i = 0; i < numFeatures; i++) {\n            const name = featureNames[i];\n            const { isEnabled, Feature: FeatureConstructor, ProjectionNode, MeasureLayout: MeasureLayoutComponent, } = featureDefinitions[name];\n            if (ProjectionNode)\n                ProjectionNodeConstructor = ProjectionNode;\n            if (isEnabled(renderedProps)) {\n                if (!this.features[name] && FeatureConstructor) {\n                    this.features[name] = new FeatureConstructor(this);\n                }\n                if (MeasureLayoutComponent) {\n                    MeasureLayout = MeasureLayoutComponent;\n                }\n            }\n        }\n        if (!this.projection && ProjectionNodeConstructor) {\n            this.projection = new ProjectionNodeConstructor(this.latestValues, this.parent && this.parent.projection);\n            const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, } = renderedProps;\n            this.projection.setOptions({\n                layoutId,\n                layout,\n                alwaysMeasureLayout: Boolean(drag) ||\n                    (dragConstraints && isRefObject(dragConstraints)),\n                visualElement: this,\n                scheduleRender: () => this.scheduleRender(),\n                /**\n                 * TODO: Update options in an effect. This could be tricky as it'll be too late\n                 * to update by the time layout animations run.\n                 * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n                 * ensuring it gets called if there's no potential layout animations.\n                 *\n                 */\n                animationType: typeof layout === \"string\" ? layout : \"both\",\n                initialPromotionConfig: initialLayoutGroupConfig,\n                layoutScroll,\n                layoutRoot,\n            });\n        }\n        return MeasureLayout;\n    }\n    updateFeatures() {\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature.isMounted) {\n                feature.update();\n            }\n            else {\n                feature.mount();\n                feature.isMounted = true;\n            }\n        }\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.options, this.props);\n    }\n    /**\n     * Measure the current viewport box with or without transforms.\n     * Only measures axis-aligned boxes, rotate and skew must be manually\n     * removed with a re-render to work.\n     */\n    measureViewportBox() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\n    }\n    /**\n     * Make a target animatable by Popmotion. For instance, if we're\n     * trying to animate width from 100px to 100vw we need to measure 100vw\n     * in pixels to determine what we really need to animate to. This is also\n     * pluggable to support Framer's custom value types like Color,\n     * and CSS variables.\n     */\n    makeTargetAnimatable(target, canMutate = true) {\n        return this.makeTargetAnimatableFromInstance(target, this.props, canMutate);\n    }\n    /**\n     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listener = props[\"on\" + key];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    getVariantContext(startAtParent = false) {\n        if (startAtParent) {\n            return this.parent ? this.parent.getVariantContext() : undefined;\n        }\n        if (!this.isControllingVariants) {\n            const context = this.parent\n                ? this.parent.getVariantContext() || {}\n                : {};\n            if (this.props.initial !== undefined) {\n                context.initial = this.props.initial;\n            }\n            return context;\n        }\n        const context = {};\n        for (let i = 0; i < numVariantProps; i++) {\n            const name = variantProps[i];\n            const prop = this.props[name];\n            if (isVariantLabel(prop) || prop === false) {\n                context[name] = prop;\n            }\n        }\n        return context;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        if (value !== this.values.get(key)) {\n            this.removeValue(key);\n            this.bindToMotionValue(key, value);\n        }\n        this.values.set(key, value);\n        this.latestValues[key] = value.get();\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key) {\n        var _a;\n        return this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);\n    }\n    /**\n     * Set the base target to later animate back to. This is currently\n     * only hydrated on creation and when we first read a value.\n     */\n    setBaseTarget(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        const valueFromInitial = typeof initial === \"string\" || typeof initial === \"object\"\n            ? (_a = resolveVariantFromProps(this.props, initial)) === null || _a === void 0 ? void 0 : _a[key]\n            : undefined;\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\n\nexport { VisualElement };\n","import { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { parseDomVariant } from './utils/parse-dom-variant.mjs';\nimport { VisualElement } from '../VisualElement.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props.style ? props.style[key] : undefined;\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n    makeTargetAnimatableFromInstance({ transition, transitionEnd, ...target }, { transformValues }, isMounted) {\n        let origin = getOrigin(target, transition || {}, this);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(this, target, origin);\n            const parsed = parseDomVariant(this, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return {\n            transition,\n            transitionEnd,\n            ...target,\n        };\n    }\n}\n\nexport { DOMVisualElement };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\n}\n\nexport { getAnimatableNone };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox({ top, left, right, bottom, }) {\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox({ x, y }) {\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    const topLeft = transformPoint({ x: point.left, y: point.top });\n    const bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    const viewportBox = measureViewportBox(element, transformPagePoint);\n    const { scroll } = rootProjectionNode;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.offset.x);\n        translateAxis(viewportBox.y, scroll.offset.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","import { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariableName } from '../dom/utils/is-css-variable.mjs';\nimport { transformProps } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, options, props) {\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps) {\n        return scrapeMotionValuesFromProps(props, prevProps);\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current)\n                    this.current.textContent = `${latest}`;\n            });\n        }\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderHTML(instance, renderState, styleProp, projection);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","const visualElementStore = new WeakMap();\n\nexport { visualElementStore };\n","import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.isSVGTag = false;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    measureInstanceViewportBox() {\n        return createBox();\n    }\n    scrapeMotionValuesFromProps(props, prevProps) {\n        return scrapeMotionValuesFromProps(props, prevProps);\n    }\n    build(renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    const current = {};\n    visualElement.values.forEach((value, key) => (current[key] = value.get()));\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    const velocity = {};\n    visualElement.values.forEach((value, key) => (velocity[key] = value.getVelocity()));\n    return velocity;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\n\nexport { resolveVariant };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","import { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { complex } from '../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    const reversedLabels = [...variantLabels].reverse();\n    reversedLabels.forEach((key) => {\n        const variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        if (visualElement.variantChildren) {\n            visualElement.variantChildren.forEach((child) => {\n                setVariants(child, variantLabels);\n            });\n        }\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b;\n    const newValueKeys = Object.keys(target).filter((key) => !visualElement.hasValue(key));\n    const numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (let i = 0; i < numNewValues; i++) {\n        const key = newValueKeys[i];\n        const targetValue = target[key];\n        let value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value, { owner: visualElement }));\n        if (origin[key] === undefined) {\n            origin[key] = value;\n        }\n        if (value !== null)\n            visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    const valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    const origin = {};\n    for (const key in target) {\n        const transitionOrigin = getOriginFromTransition(key, transition);\n        if (transitionOrigin !== undefined) {\n            origin[key] = transitionOrigin;\n        }\n        else {\n            const value = visualElement.getValue(key);\n            if (value) {\n                origin[key] = value.get();\n            }\n        }\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","function addUniqueItem(arr, item) {\n    if (arr.indexOf(item) === -1)\n        arr.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    if (index > -1)\n        arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        const [item] = arr.splice(fromIndex, 1);\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","import { mix } from './mix.mjs';\nimport { invariant } from './errors.mjs';\nimport { hslaToRgba } from './hsla-to-rgba.mjs';\nimport { hex } from '../value/types/color/hex.mjs';\nimport { rgba } from '../value/types/color/rgba.mjs';\nimport { hsla } from '../value/types/color/hsla.mjs';\n\n// Linear color space blending\n// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw\n// Demonstrated http://codepen.io/osublake/pen/xGVVaN\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    return Math.sqrt(Math.max(0, v * (to * to - fromExpo) + fromExpo));\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nfunction asRGBA(color) {\n    const type = getColorType(color);\n    invariant(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`);\n    let model = type.parse(color);\n    if (type === hsla) {\n        // TODO Remove this cast - needed since Framer Motion's stricter typing\n        model = hslaToRgba(model);\n    }\n    return model;\n}\nconst mixColor = (from, to) => {\n    const fromRGBA = asRGBA(from);\n    const toRGBA = asRGBA(to);\n    const blended = { ...fromRGBA };\n    return (v) => {\n        blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);\n        blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);\n        blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);\n        blended.alpha = mix(fromRGBA.alpha, toRGBA.alpha, v);\n        return rgba.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","import { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { pipe } from './pipe.mjs';\nimport { warning } from './errors.mjs';\nimport { color } from '../value/types/color/index.mjs';\nimport { complex, analyseComplexValue } from '../value/types/complex/index.mjs';\n\nconst mixImmediate = (origin, target) => (p) => `${p > 0 ? target : origin}`;\nfunction getMixer(origin, target) {\n    if (typeof origin === \"number\") {\n        return (v) => mix(origin, target, v);\n    }\n    else if (color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return origin.startsWith(\"var(\")\n            ? mixImmediate(origin, target)\n            : mixComplex(origin, target);\n    }\n}\nconst mixArray = (from, to) => {\n    const output = [...from];\n    const numValues = output.length;\n    const blendValue = from.map((fromThis, i) => getMixer(fromThis, to[i]));\n    return (v) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](v);\n        }\n        return output;\n    };\n};\nconst mixObject = (origin, target) => {\n    const output = { ...origin, ...target };\n    const blendValue = {};\n    for (const key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(origin[key], target[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n};\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyseComplexValue(origin);\n    const targetStats = analyseComplexValue(target);\n    const canInterpolate = originStats.numVars === targetStats.numVars &&\n        originStats.numColors === targetStats.numColors &&\n        originStats.numNumbers >= targetStats.numNumbers;\n    if (canInterpolate) {\n        return pipe(mixArray(originStats.values, targetStats.values), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return mixImmediate(origin, target);\n    }\n};\n\nexport { mixArray, mixComplex, mixObject };\n","import { invariant } from './errors.mjs';\nimport { color } from '../value/types/color/index.mjs';\nimport { clamp } from './clamp.mjs';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.mjs';\nimport { pipe } from './pipe.mjs';\nimport { progress } from './progress.mjs';\nimport { noop } from './noop.mjs';\n\nconst mixNumber = (from, to) => (p) => mix(from, to, p);\nfunction detectMixerFactory(v) {\n    if (typeof v === \"number\") {\n        return mixNumber;\n    }\n    else if (typeof v === \"string\") {\n        return color.test(v) ? mixColor : mixComplex;\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === \"object\") {\n        return mixObject;\n    }\n    return mixNumber;\n}\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || detectMixerFactory(output[0]);\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] || noop : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revist this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\n */\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, \"Both input and output ranges must be the same length\");\n    /**\n     * If we're only provided a single input, we can just make a function\n     * that returns the output.\n     */\n    if (inputLength === 1)\n        return () => output[0];\n    // If input runs highest -> lowest, reverse both arrays\n    if (input[0] > input[inputLength - 1]) {\n        input = [...input].reverse();\n        output = [...output].reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const numMixers = mixers.length;\n    const interpolator = (v) => {\n        let i = 0;\n        if (numMixers > 1) {\n            for (; i < input.length - 2; i++) {\n                if (v < input[i + 1])\n                    break;\n            }\n        }\n        const progressInRange = progress(input[i], input[i + 1], v);\n        return mixers[i](progressInRange);\n    };\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nconst isNumericalString = (v) => /^\\-?\\d*\\.?\\d+$/.test(v);\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = (v) => /^0[^.\\s]+$/.test(v);\n\nexport { isZeroValueString };\n","function memo(callback) {\n    let result;\n    return () => {\n        if (result === undefined)\n            result = callback();\n        return result;\n    };\n}\n\nexport { memo };\n","/*\n  Value in range from progress\n\n  Given a lower limit and an upper limit, we return the value within\n  that range as expressed by progress (usually a number from 0 to 1)\n\n  So progress = 0.5 would change\n\n  from -------- to\n\n  to\n\n  from ---- to\n\n  E.g. from = 10, to = 20, progress = 0.5 => 15\n\n  @param [number]: Lower limit of range\n  @param [number]: Upper limit of range\n  @param [number]: The progress between lower and upper limits expressed 0-1\n  @return [number]: Value as calculated from progress within range (not limited within range)\n*/\nconst mix = (from, to, progress) => -progress * from + progress * to + from;\n\nexport { mix };\n","import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n","import { mix } from '../mix.mjs';\nimport { progress } from '../progress.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mix(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n","/**\n * Pipe\n * Compose other transformers to run linearily\n * pipe(min(20), max(40))\n * @param  {...functions} transformers\n * @return {function}\n */\nconst combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","/*\n  Progress within given range\n\n  Given a lower limit and an upper limit, we return the progress\n  (expressed as a number 0-1) represented by the given value, and\n  limit that progress to within 0-1.\n\n  @param [number]: Lower limit\n  @param [number]: Upper limit\n  @param [number]: Value to find progress within given range\n  @return [number]: Progress of value within range as expressed 0-1\n*/\nconst progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n    constructor() {\n        this.subscriptions = [];\n    }\n    add(handler) {\n        addUniqueItem(this.subscriptions, handler);\n        return () => removeItem(this.subscriptions, handler);\n    }\n    notify(a, b, c) {\n        const numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (let i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                const handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    }\n    getSize() {\n        return this.subscriptions.length;\n    }\n    clear() {\n        this.subscriptions.length = 0;\n    }\n}\n\nexport { SubscriptionManager };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\nconst millisecondsToSeconds = (milliseconds) => milliseconds / 1000;\n\nexport { millisecondsToSeconds, secondsToMilliseconds };\n","/*\n  Convert velocity into velocity per second\n\n  @param [number]: Unit per frame\n  @param [number]: Frame duration in ms\n*/\nfunction velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { frame, frameData } from '../frameloop/frame.mjs';\n\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"10.16.5\";\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            this.prev = this.current;\n            this.current = v;\n            // Update timestamp\n            const { delta, timestamp } = frameData;\n            if (this.lastUpdated !== timestamp) {\n                this.timeDelta = delta;\n                this.lastUpdated = timestamp;\n                frame.postRender(this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (this.prev !== this.current && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update velocity subscribers\n            if (this.events.velocityChange) {\n                this.events.velocityChange.notify(this.getVelocity());\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = () => frame.postRender(this.velocityCheck);\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = ({ timestamp }) => {\n            if (timestamp !== this.lastUpdated) {\n                this.prev = this.current;\n                if (this.events.velocityChange) {\n                    this.events.velocityChange.notify(this.getVelocity());\n                }\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\n        this.owner = options.owner;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = prev;\n        this.timeDelta = delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = \"\";\n    let g = \"\";\n    let b = \"\";\n    let a = \"\";\n    // If we have 6 characters, ie #FF0000\n    if (v.length > 5) {\n        r = v.substring(1, 3);\n        g = v.substring(3, 5);\n        b = v.substring(5, 7);\n        a = v.substring(7, 9);\n        // Or we have 3 characters, ie #F00\n    }\n    else {\n        r = v.substring(1, 2);\n        g = v.substring(2, 3);\n        b = v.substring(3, 4);\n        a = v.substring(4, 5);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString(\"#\"),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString(\"hsl\", \"hue\"),\n    parse: splitColor(\"hue\", \"saturation\", \"lightness\"),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return (\"hsla(\" +\n            Math.round(hue) +\n            \", \" +\n            percent.transform(sanitize(saturation)) +\n            \", \" +\n            percent.transform(sanitize(lightness)) +\n            \", \" +\n            sanitize(alpha.transform(alpha$1)) +\n            \")\");\n    },\n};\n\nexport { hsla };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty(\"red\")\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { clamp } from '../../../utils/clamp.mjs';\nimport { number, alpha } from '../numbers/index.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = (v) => clamp(0, 255, v);\nconst rgbUnit = {\n    ...number,\n    transform: (v) => Math.round(clampRgbUnit(v)),\n};\nconst rgba = {\n    test: isColorString(\"rgb\", \"red\"),\n    parse: splitColor(\"red\", \"green\", \"blue\"),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => \"rgba(\" +\n        rgbUnit.transform(red) +\n        \", \" +\n        rgbUnit.transform(green) +\n        \", \" +\n        rgbUnit.transform(blue) +\n        \", \" +\n        sanitize(alpha.transform(alpha$1)) +\n        \")\",\n};\n\nexport { rgbUnit, rgba };\n","import { isString, singleColorRegex, floatRegex } from '../utils.mjs';\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","import { cssVariableRegex } from '../../../render/dom/utils/is-css-variable.mjs';\nimport { noop } from '../../../utils/noop.mjs';\nimport { color } from '../color/index.mjs';\nimport { number } from '../numbers/index.mjs';\nimport { colorRegex, floatRegex, isString, sanitize } from '../utils.mjs';\n\nfunction test(v) {\n    var _a, _b;\n    return (isNaN(v) &&\n        isString(v) &&\n        (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) +\n            (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) >\n            0);\n}\nconst cssVarTokeniser = {\n    regex: cssVariableRegex,\n    countKey: \"Vars\",\n    token: \"${v}\",\n    parse: noop,\n};\nconst colorTokeniser = {\n    regex: colorRegex,\n    countKey: \"Colors\",\n    token: \"${c}\",\n    parse: color.parse,\n};\nconst numberTokeniser = {\n    regex: floatRegex,\n    countKey: \"Numbers\",\n    token: \"${n}\",\n    parse: number.parse,\n};\nfunction tokenise(info, { regex, countKey, token, parse }) {\n    const matches = info.tokenised.match(regex);\n    if (!matches)\n        return;\n    info[\"num\" + countKey] = matches.length;\n    info.tokenised = info.tokenised.replace(regex, token);\n    info.values.push(...matches.map(parse));\n}\nfunction analyseComplexValue(value) {\n    const originalValue = value.toString();\n    const info = {\n        value: originalValue,\n        tokenised: originalValue,\n        values: [],\n        numVars: 0,\n        numColors: 0,\n        numNumbers: 0,\n    };\n    if (info.value.includes(\"var(--\"))\n        tokenise(info, cssVarTokeniser);\n    tokenise(info, colorTokeniser);\n    tokenise(info, numberTokeniser);\n    return info;\n}\nfunction parseComplexValue(v) {\n    return analyseComplexValue(v).values;\n}\nfunction createTransformer(source) {\n    const { values, numColors, numVars, tokenised } = analyseComplexValue(source);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            if (i < numVars) {\n                output = output.replace(cssVarTokeniser.token, v[i]);\n            }\n            else if (i < numVars + numColors) {\n                output = output.replace(colorTokeniser.token, color.transform(v[i]));\n            }\n            else {\n                output = output.replace(numberTokeniser.token, sanitize(v[i]));\n            }\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === \"number\" ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parseComplexValue(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = {\n    test,\n    parse: parseComplexValue,\n    createTransformer,\n    getAnimatableNone,\n};\n\nexport { analyseComplexValue, complex };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n"],"names":["calcAngularFreq","undampedFreq","dampingRatio","Math","sqrt","durationKeys","physicsKeys","isSpringType","options","keys","some","undefined","key","spring","keyframes","restDelta","restSpeed","resolveSpring","origin","target","length","state","done","value","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","getSpringOptions","springOptions","derived","findSpring","bounce","envelope","derivative","errors","K","time_conversion","w","clamp","u","X","exponentialDecay","delta","b","safeMin","exp","e","pow","g","factor","d","f","a","initialGuess","approximateRoot","result","i","isNaN","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","abs","angularFreq","t","sin","cos","dampedAngularFreq","freqForT","min","sinh","cosh","calculatedDuration","next","current","currentVelocity","utils_velocity","P","isBelowVelocityThreshold","isBelowDisplacementThreshold","maxGeneratorDuration","calcGeneratorDuration","generator","Infinity","calcGeneratorVelocity","resolveValue","prevT","max","_utils_velocity_per_second_mjs__WEBPACK_IMPORTED_MODULE_0__","R","instantAnimationState","isBezierDefinition","Array","isArray","easing","cubicBezierAsString","c","supportedWaapiEasing","linear","ease","easeIn","easeOut","easeInOut","circIn","circOut","backIn","backOut","calcBezier","a1","a2","cubicBezier","mX1","mY1","mX2","mY2","noop","Z","getTForX","binarySubdivide","x","lowerBound","upperBound","currentX","currentT","aX","mirrorEasing","p","reverseEasing","acos","circInOut","backInOut","easingLookup","anticipate","easingDefinitionToFunction","definition","k","x1","y1","x2","y2","keyframeValues","times","easingFunctions","is_easing_array","N","map","absoluteTimes","offset","offsets_default","Y","o","mapTimeToKeyframe","interpolate","s","values","splice","inertia","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","timeReachedBoundary","spring$1","isOutOfBounds","v","nearestBoundary","amplitude","ideal","calcDelta","calcLatest","applyFriction","latest","checkCatchBoundary","S","hasUpdatedFrame","frameloopDriver","passTimestamp","timestamp","update","start","frameloop_frame","Wi","stop","Pn","now","frameData","isProcessing","performance","types","decay","tween","animateValue","autoplay","delay","driver","keyframes$1","type","repeat","repeatDelay","repeatType","onPlay","onStop","onComplete","onUpdate","resolveFinishedPromise","currentFinishedPromise","animationDriver","mapNumbersToKeyframes","mirroredGenerator","speed","hasStopped","updateFinishedPromise","Promise","resolve","generatorFactory","reverse","playState","holdTime","startTime","cancelTime","calc_duration","resolvedDuration","totalDuration","currentTime","tick","round","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","floor","iterationProgress","iterationIsOdd","Boolean","isAnimationFinished","finish","stopAnimationDriver","cancel","play","controls","then","reject","time","newTime","newSpeed","pause","complete","sample","supportsWaapi","memo","Object","hasOwnProperty","call","Element","prototype","acceleratedValues","Set","requiresPregeneratedKeyframes","valueName","isWaapiSupportedEasing","every","underDampedSpring","criticallyDampedSpring","keyframesTransition","getDefaultTransition","valueKey","transform","G","has","startsWith","isAnimatable","complex","test","animateMotionValue","transition","valueTransition","getValueTransition","getKeyframes","animatableTemplateValue","isTargetAnimatable","defaultOrigin","from","get","noneKeyframeIndexes","is_zero_value_string","W","push","index","animatable_none","T","originKeyframe","targetKeyframe","isOriginAnimatable","getVelocity","set","isTransitionDefined","when","_delay","delayChildren","staggerChildren","staggerDirection","createInstantAnimation","setValue","owner","HTMLElement","getProps","acceleratedAnimation","createAcceleratedAnimation","canAccelerateAnimation","sampleAnimation","pregeneratedKeyframes","animation","animateStyle","element","keyframeOptions","mapEasingToNativeEasing","animate","fill","iterations","direction","syncStart","document","timeline","cancelAnimation","safeCancel","onfinish","getFinalKeyframe","attachTimeline","playbackRate","setWithVelocity","optimizedAppearDataAttribute","camel_to_dash","D","animateTarget","visualElement","transitionOverride","transitionEnd","makeTargetAnimatable","willChange","getValue","animations","animationTypeState","animationState","getState","valueTarget","shouldBlockAnimation","protectedKeys","needsAnimating","shouldBlock","window","HandoffAppearAnimations","hasAnimated","appearId","motion_value","shouldReduceMotion","is","L","add","remove","all","setters","CD","isEasingArray","createAxis","createBox","y","splitCSSVariableRegex","getVariableValue","depth","token","fallback","parseCSSVariable","match","exec","resolved","getComputedStyle","getPropertyValue","trimmed","trim","is_numerical_string","parseFloat","is_css_variable","tm","positionalKeys","isPositionalKey","hasPositionalKey","isNumOrPxType","numbers","Rx","units","px","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","_","filter","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","top","left","bottom","right","translateX","translateY","convertChangedValueTypes","changedKeys","originBbox","measureViewportBox","elementComputedStyle","display","setStaticValue","forEach","render","targetBbox","jump","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","hasValue","fromType","dimensions","C","to","is_keyframes_target","numKeyframes","fromIndex","removeNonTranslationalTransform","removedTransforms","scrollY","indexOf","pageYOffset","convertedTarget","is_browser","j","scrollTo","parseDomVariant","resolveCSSVariables","prefersReducedMotion","hasReducedMotionListener","featureNames","definitions","A","numFeatures","propEventHandlers","numVariantProps","variant_props","V","VisualElement","constructor","parent","props","presenceContext","reducedMotionConfig","visualState","children","isVariantNode","isControllingVariants","Map","features","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","notify","latestValues","triggerBuild","renderInstance","renderState","style","projection","scheduleRender","baseTarget","initialValues","initial","is_controlling_variants","M","variantChildren","manuallyAnimateOnMount","initialMotionValues","scrapeMotionValuesFromProps","is_motion_value","_props","_prevProps","mount","instance","store","removeFromVariantTree","addVariantChild","bindToMotionValue","initPrefersReducedMotion","matchMedia","motionMediaQuery","setReducedMotionPreferences","matches","addListener","unmount","delete","clear","valueIsTransform","removeOnChange","on","latestValue","isTransformDirty","removeOnRenderRequest","sortNodePosition","other","sortInstanceNodePosition","loadFeatures","renderedProps","isStrict","preloadedFeatures","initialLayoutGroupConfig","ProjectionNodeConstructor","MeasureLayout","name","isEnabled","Feature","FeatureConstructor","ProjectionNode","MeasureLayoutComponent","layoutId","layout","drag","dragConstraints","layoutScroll","layoutRoot","setOptions","alwaysMeasureLayout","is_ref_object","I","animationType","initialPromotionConfig","updateFeatures","feature","isMounted","build","measureInstanceViewportBox","models","dO","getStaticValue","canMutate","makeTargetAnimatableFromInstance","transformTemplate","prevProps","prevPresenceContext","listener","updateMotionValuesFromProps","prev","nextValue","prevValue","addValue","es_value","BX","existingValue","removeValue","handleChildMotionValue","getVariant","variants","getTransformPagePoint","transformPagePoint","getClosestVariantNode","getVariantContext","startAtParent","context","prop","is_variant_label","$","child","closestVariantNode","unsubscribe","removeValueFromRenderState","defaultValue","readValue","_a","getBaseTargetFromProps","readValueFromInstance","setBaseTarget","getBaseTarget","valueFromInitial","resolve_variants","eventName","callback","subscription_manager","args","DOMVisualElement","compareDocumentPosition","vars","transformValues","P$","GJ","parsed","getAnimatableNone","defaultValueType","_defaults_mjs__WEBPACK_IMPORTED_MODULE_0__","_value_types_complex_filter_mjs__WEBPACK_IMPORTED_MODULE_1__","h","_value_types_complex_index_mjs__WEBPACK_IMPORTED_MODULE_2__","defaultValueTypes","_number_mjs__WEBPACK_IMPORTED_MODULE_0__","color","_value_types_color_index_mjs__WEBPACK_IMPORTED_MODULE_1__","backgroundColor","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","_value_types_complex_filter_mjs__WEBPACK_IMPORTED_MODULE_2__","WebkitFilter","getDefaultValueType","dimensionValueTypes","aQ","RW","vw","vh","parse","findDimensionValueType","find","l","testValueType","HTMLVisualElement","J","defaultType","defaults","default","computedStyle","f9","convertBoundingBoxToBox","transformBoxPoints","point","transformPoint","topLeft","bottomRight","getBoundingClientRect","build_styles","r","scrape_motion_values","U","childSubscription","textContent","styleProp","visualElementStore","WeakMap","SVGVisualElement","_dom_DOMVisualElement_mjs__WEBPACK_IMPORTED_MODULE_0__","arguments","isSVGTag","_html_utils_transform_mjs__WEBPACK_IMPORTED_MODULE_1__","_dom_value_types_defaults_mjs__WEBPACK_IMPORTED_MODULE_2__","_dom_utils_camel_to_dash_mjs__WEBPACK_IMPORTED_MODULE_4__","getAttribute","_projection_geometry_models_mjs__WEBPACK_IMPORTED_MODULE_5__","_utils_scrape_motion_values_mjs__WEBPACK_IMPORTED_MODULE_6__","_utils_build_attrs_mjs__WEBPACK_IMPORTED_MODULE_7__","_utils_render_mjs__WEBPACK_IMPORTED_MODULE_8__","_utils_is_svg_tag_mjs__WEBPACK_IMPORTED_MODULE_9__","tagName","resolveVariant","custom","_resolve_variants_mjs__WEBPACK_IMPORTED_MODULE_0__","getCurrent","valueTypes","findValueType","setTarget","resolve_dynamic_variants","resolve_value","checkTargetForNewValues","_b","newValueKeys","numNewValues","targetValue","getOrigin","transitionOrigin","getOriginFromTransition","addUniqueItem","arr","item","removeItem","hueToRgb","q","mixLinearColor","fromExpo","colorTypes","hex","rgba","m","hsla","getColorType","asRGBA","model","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","mixColor","fromRGBA","toRGBA","blended","mix","mixImmediate","getMixer","mixComplex","mixArray","output","numValues","blendValue","fromThis","mixObject","template","createTransformer","originStats","targetStats","canInterpolate","numVars","numColors","numNumbers","pipe","z","mixNumber","input","isClamp","mixer","inputLength","mixers","createMixers","customMixer","mixerFactory","detectMixerFactory","numMixers","easingFunction","interpolator","progressInRange","isNumericalString","isZeroValueString","defaultOffset","_fill_mjs__WEBPACK_IMPORTED_MODULE_0__","fillOffset","remaining","offsetProgress","_progress_mjs__WEBPACK_IMPORTED_MODULE_0__","_mix_mjs__WEBPACK_IMPORTED_MODULE_1__","combineFunctions","transformers","reduce","toFromDifference","SubscriptionManager","subscriptions","handler","_array_mjs__WEBPACK_IMPORTED_MODULE_0__","y4","cl","numSubscriptions","getSize","secondsToMilliseconds","seconds","millisecondsToSeconds","milliseconds","velocityPerSecond","frameDuration","isFloat","collectMotionValues","MotionValue","init","version","timeDelta","lastUpdated","canTrackVelocity","updateAndNotify","_frameloop_frame_mjs__WEBPACK_IMPORTED_MODULE_0__","postRender","scheduleVelocityCheck","change","velocityChange","renderRequest","velocityCheck","onChange","subscription","_utils_subscription_manager_mjs__WEBPACK_IMPORTED_MODULE_1__","read","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","getPrevious","_utils_velocity_per_second_mjs__WEBPACK_IMPORTED_MODULE_2__","startAnimation","animationStart","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","motionValue","_utils_mjs__WEBPACK_IMPORTED_MODULE_0__","substring","parseInt","_rgba_mjs__WEBPACK_IMPORTED_MODULE_1__","alpha$1","_numbers_units_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_mjs__WEBPACK_IMPORTED_MODULE_2__","Nw","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_3__","Fq","_rgba_mjs__WEBPACK_IMPORTED_MODULE_0__","_hex_mjs__WEBPACK_IMPORTED_MODULE_1__","_hsla_mjs__WEBPACK_IMPORTED_MODULE_2__","_utils_mjs__WEBPACK_IMPORTED_MODULE_3__","HD","clampRgbUnit","_utils_clamp_mjs__WEBPACK_IMPORTED_MODULE_0__","rgbUnit","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_1__","isColorString","testProp","mj","splitColor","aName","bName","cName","KP","maxDefaults","applyDefaultFilter","slice","number","unit","replace","functionRegex","_index_mjs__WEBPACK_IMPORTED_MODULE_1__","functions","join","cssVarTokeniser","regex","_render_dom_utils_is_css_variable_mjs__WEBPACK_IMPORTED_MODULE_1__","Xp","countKey","_utils_noop_mjs__WEBPACK_IMPORTED_MODULE_2__","colorTokeniser","dA","_color_index_mjs__WEBPACK_IMPORTED_MODULE_3__","numberTokeniser","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_4__","tokenise","info","tokenised","analyseComplexValue","originalValue","toString","includes","parseComplexValue","source","convertNumbersToZero","transformer","isWillChangeMotionValue","_utils_is_motion_value_mjs__WEBPACK_IMPORTED_MODULE_0__"],"sourceRoot":""}