{"version":3,"file":"react/js/vendor.framer-motion@current-66bb3aca.b5e541cea8180248ed67.js","mappings":"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","sources":["webpack:///./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/generators/inertia.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/waapi/easing.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/GroupPlaybackControls.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/interfaces/single-value.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-none.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack:///./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack:///./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack:///./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack:///./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs"],"sourcesContent":["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","const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\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 = (value, name) => {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (name === \"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 { flushKeyframeResolvers } from '../../render/utils/KeyframesResolver.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\nclass BaseAnimation {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", ...options }) {\n        // Track whether the animation has been stopped. Stopped animations won't restart.\n        this.isStopped = false;\n        this.hasAttemptedResolve = false;\n        this.options = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            ...options,\n        };\n        this.updateFinishedPromise();\n    }\n    /**\n     * A getter for resolved data. If keyframes are not yet resolved, accessing\n     * this.resolved will synchronously flush all pending keyframe resolvers.\n     * This is a deoptimisation, but at its worst still batches read/writes.\n     */\n    get resolved() {\n        if (!this._resolved && !this.hasAttemptedResolve) {\n            flushKeyframeResolvers();\n        }\n        return this._resolved;\n    }\n    /**\n     * A method to be called when the keyframes resolver completes. This method\n     * will check if its possible to run the animation and, if not, skip it.\n     * Otherwise, it will call initPlayback on the implementing class.\n     */\n    onKeyframesResolved(keyframes, finalKeyframe) {\n        this.hasAttemptedResolve = true;\n        const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {\n            // Finish immediately\n            if (instantAnimationState.current || !delay) {\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete === null || onComplete === void 0 ? void 0 : onComplete();\n                this.resolveFinishedPromise();\n                return;\n            }\n            // Finish after a delay\n            else {\n                this.options.duration = 0;\n            }\n        }\n        const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);\n        if (resolvedAnimation === false)\n            return;\n        this._resolved = {\n            keyframes,\n            finalKeyframe,\n            ...resolvedAnimation,\n        };\n        this.onPostResolved();\n    }\n    onPostResolved() { }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.currentFinishedPromise.then(resolve, reject);\n    }\n    updateFinishedPromise() {\n        this.currentFinishedPromise = new Promise((resolve) => {\n            this.resolveFinishedPromise = resolve;\n        });\n    }\n}\n\nexport { BaseAnimation };\n","import { warning } from '../../../utils/errors.mjs';\nimport { isAnimatable } from '../../utils/is-animatable.mjs';\n\nfunction hasKeyframesChanged(keyframes) {\n    const current = keyframes[0];\n    if (keyframes.length === 1)\n        return true;\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] !== current)\n            return true;\n    }\n}\nfunction canAnimate(keyframes, name, type, velocity) {\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    if (originKeyframe === null)\n        return false;\n    /**\n     * These aren't traditionally animatable but we do support them.\n     * In future we could look into making this more generic or replacing\n     * this function with mix() === mixImmediate\n     */\n    if (name === \"display\" || name === \"visibility\")\n        return true;\n    const targetKeyframe = keyframes[keyframes.length - 1];\n    const isOriginAnimatable = isAnimatable(originKeyframe, name);\n    const isTargetAnimatable = isAnimatable(targetKeyframe, name);\n    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} 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    // Always skip if any of these are true\n    if (!isOriginAnimatable || !isTargetAnimatable) {\n        return false;\n    }\n    return hasKeyframesChanged(keyframes) || (type === \"spring\" && velocity);\n}\n\nexport { canAnimate };\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","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            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 0) {\n                    /**\n                     * We only need to calculate velocity for under-damped springs\n                     * as over- and critically-damped springs can't overshoot, so\n                     * checking only for displacement is enough.\n                     */\n                    if (dampingRatio < 1) {\n                        currentVelocity = calcGeneratorVelocity(resolveSpring, t, current);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n    };\n}\n\nexport { spring };\n","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), // TODO: This should be passing * 1000\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 { 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 { time } from '../../../frameloop/sync-time.mjs';\nimport { 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 : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n","import { KeyframeResolver } from '../../render/utils/KeyframesResolver.mjs';\nimport { spring } from '../generators/spring/index.mjs';\nimport { inertia } from '../generators/inertia.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { mix } from '../../utils/mix/index.mjs';\nimport { calcGeneratorDuration } from '../generators/utils/calc-duration.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\nimport { invariant } from '../../utils/errors.mjs';\nimport { frameloopDriver } from './drivers/driver-frameloop.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\nconst generators = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\nconst percentToProgress = (percent) => percent / 100;\n/**\n * Animation that runs on the main thread. Designed to be WAAPI-spec in the subset of\n * features we expose publically. Mostly the compatibility is to ensure visual identity\n * between both WAAPI and main thread animations.\n */\nclass MainThreadAnimation extends BaseAnimation {\n    constructor({ KeyframeResolver: KeyframeResolver$1 = KeyframeResolver, ...options }) {\n        super(options);\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * The time at which the animation was started.\n         */\n        this.startTime = null;\n        /**\n         * The time at which the animation was cancelled.\n         */\n        this.cancelTime = null;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * The state of the animation to apply when the animation is resolved. This\n         * allows calls to the public API to control the animation before it is resolved,\n         * without us having to resolve it first.\n         */\n        this.pendingPlayState = \"running\";\n        this.state = \"idle\";\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            this.resolver.cancel();\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            const { onStop } = this.options;\n            onStop && onStop();\n        };\n        const { name, motionValue, keyframes } = this.options;\n        const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);\n        if (name && motionValue && motionValue.owner) {\n            this.resolver = motionValue.owner.resolveKeyframes(keyframes, onResolved, name, motionValue);\n        }\n        else {\n            this.resolver = new KeyframeResolver$1(keyframes, onResolved, name, motionValue);\n        }\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes$1) {\n        const { type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = this.options;\n        const generatorFactory = generators[type] || keyframes;\n        /**\n         * If our generator doesn't support mixing numbers, we need to replace keyframes with\n         * [0, 100] and then make a function that maps that to the actual keyframes.\n         *\n         * 100 is chosen instead of 1 as it works nicer with spring animations.\n         */\n        let mapPercentToKeyframes;\n        let mirroredGenerator;\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            if (process.env.NODE_ENV !== \"production\") {\n                invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n            }\n            mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            mirroredGenerator = generatorFactory({\n                ...this.options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\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) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        const resolvedDuration = calculatedDuration + repeatDelay;\n        const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n        return {\n            generator,\n            mirroredGenerator,\n            mapPercentToKeyframes,\n            calculatedDuration,\n            resolvedDuration,\n            totalDuration,\n        };\n    }\n    onPostResolved() {\n        const { autoplay = true } = this.options;\n        this.play();\n        if (this.pendingPlayState === \"paused\" || !autoplay) {\n            this.pause();\n        }\n        else {\n            this.state = this.pendingPlayState;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { resolved } = this;\n        // If the animations has failed to resolve, return the final keyframe.\n        if (!resolved) {\n            const { keyframes } = this.options;\n            return { done: true, value: keyframes[keyframes.length - 1] };\n        }\n        const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes, calculatedDuration, totalDuration, resolvedDuration, } = resolved;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;\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 (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        // Update currentTime\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else if (this.holdTime !== null) {\n            this.currentTime = this.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            this.currentTime =\n                Math.round(timestamp - this.startTime) * this.speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.speed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        const state = isInDelayPhase\n            ? { done: false, value: keyframes[0] }\n            : frameGenerator.next(elapsed);\n        if (mapPercentToKeyframes) {\n            state.value = mapPercentToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.speed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        if (isAnimationFinished && finalKeyframe !== undefined) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    get duration() {\n        const { resolved } = this;\n        return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.holdTime !== null || this.speed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.speed;\n        }\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        this.playbackSpeed = newSpeed;\n        if (hasChanged) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (!this.resolver.isScheduled) {\n            this.resolver.resume();\n        }\n        if (!this._resolved) {\n            this.pendingPlayState = \"running\";\n            return;\n        }\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, onPlay } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        onPlay && onPlay();\n        const now = this.driver.now();\n        if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime || this.state === \"finished\") {\n            this.startTime = now;\n        }\n        if (this.state === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        this.cancelTime = this.startTime;\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        var _a;\n        if (!this._resolved) {\n            this.pendingPlayState = \"paused\";\n            return;\n        }\n        this.state = \"paused\";\n        this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.pendingPlayState = this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.teardown();\n        this.state = \"finished\";\n        const { onComplete } = this.options;\n        onComplete && onComplete();\n    }\n    cancel() {\n        if (this.cancelTime !== null) {\n            this.tick(this.cancelTime);\n        }\n        this.teardown();\n        this.updateFinishedPromise();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        this.startTime = this.cancelTime = null;\n        this.resolver.cancel();\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(time) {\n        this.startTime = 0;\n        return this.tick(time, true);\n    }\n}\n// Legacy interface\nfunction animateValue(options) {\n    return new MainThreadAnimation(options);\n}\n\nexport { MainThreadAnimation, animateValue };\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 { isBezierDefinition } from '../../../easing/utils/is-bezier-definition.mjs';\n\nfunction isWaapiSupportedEasing(easing) {\n    return Boolean(!easing ||\n        (typeof easing === \"string\" && easing in supportedWaapiEasing) ||\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 mapEasingToNativeEasingWithDefault(easing) {\n    return (mapEasingToNativeEasing(easing) ||\n        supportedWaapiEasing.easeOut);\n}\nfunction mapEasingToNativeEasing(easing) {\n    if (!easing) {\n        return undefined;\n    }\n    else if (isBezierDefinition(easing)) {\n        return cubicBezierAsString(easing);\n    }\n    else if (Array.isArray(easing)) {\n        return easing.map(mapEasingToNativeEasingWithDefault);\n    }\n    else {\n        return supportedWaapiEasing[easing];\n    }\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","import { time } from '../../frameloop/sync-time.mjs';\nimport { DOMKeyframesResolver } from '../../render/dom/DOMKeyframesResolver.mjs';\nimport { memo } from '../../utils/memo.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { MainThreadAnimation } from './MainThreadAnimation.mjs';\nimport { animateStyle } from './waapi/index.mjs';\nimport { isWaapiSupportedEasing } from './waapi/easing.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.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    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved\n    // or until we implement support for linear() easing.\n    // \"background-color\"\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;\n/**\n * Check if an animation can run natively via WAAPI or requires pregenerated keyframes.\n * WAAPI doesn't support spring or function easings so we run these as JS animation before\n * handing off.\n */\nfunction requiresPregeneratedKeyframes(options) {\n    return (options.type === \"spring\" ||\n        options.name === \"backgroundColor\" ||\n        !isWaapiSupportedEasing(options.ease));\n}\nfunction pregenerateKeyframes(keyframes, options) {\n    /**\n     * Create a main-thread animation to pregenerate keyframes.\n     * We sample this at regular intervals to generate keyframes that we then\n     * linearly interpolate between.\n     */\n    const sampleAnimation = new MainThreadAnimation({\n        ...options,\n        keyframes,\n        repeat: 0,\n        delay: 0,\n        isGenerator: true,\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    return {\n        times: undefined,\n        keyframes: pregeneratedKeyframes,\n        duration: t - sampleDelta,\n        ease: \"linear\",\n    };\n}\nclass AcceleratedAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        const { name, motionValue, keyframes } = this.options;\n        this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue);\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes, finalKeyframe) {\n        var _a;\n        let { duration = 300, times, ease, type, motionValue, name, } = this.options;\n        /**\n         * If element has since been unmounted, return false to indicate\n         * the animation failed to initialised.\n         */\n        if (!((_a = motionValue.owner) === null || _a === void 0 ? void 0 : _a.current)) {\n            return false;\n        }\n        /**\n         * If this animation needs pre-generated keyframes then generate.\n         */\n        if (requiresPregeneratedKeyframes(this.options)) {\n            const { onComplete, onUpdate, motionValue, ...options } = this.options;\n            const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);\n            keyframes = pregeneratedAnimation.keyframes;\n            // If this is a very short animation, ensure we have\n            // at least two keyframes to animate between as older browsers\n            // can't animate between a single keyframe.\n            if (keyframes.length === 1) {\n                keyframes[1] = keyframes[0];\n            }\n            duration = pregeneratedAnimation.duration;\n            times = pregeneratedAnimation.times;\n            ease = pregeneratedAnimation.ease;\n            type = \"keyframes\";\n        }\n        const animation = animateStyle(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });\n        // Override the browser calculated startTime with one synchronised to other JS\n        // and WAAPI animations starting this event loop.\n        animation.startTime = time.now();\n        if (this.pendingTimeline) {\n            animation.timeline = this.pendingTimeline;\n            this.pendingTimeline = undefined;\n        }\n        else {\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                const { onComplete } = this.options;\n                motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.cancel();\n                this.resolveFinishedPromise();\n            };\n        }\n        return {\n            animation,\n            duration,\n            times,\n            type,\n            ease,\n            keyframes: keyframes,\n        };\n    }\n    get duration() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { duration } = resolved;\n        return millisecondsToSeconds(duration);\n    }\n    get time() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { animation } = resolved;\n        return millisecondsToSeconds(animation.currentTime || 0);\n    }\n    set time(newTime) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.currentTime = secondsToMilliseconds(newTime);\n    }\n    get speed() {\n        const { resolved } = this;\n        if (!resolved)\n            return 1;\n        const { animation } = resolved;\n        return animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.playbackRate = newSpeed;\n    }\n    get state() {\n        const { resolved } = this;\n        if (!resolved)\n            return \"idle\";\n        const { animation } = resolved;\n        return animation.playState;\n    }\n    /**\n     * Replace the default DocumentTimeline with another AnimationTimeline.\n     * Currently used for scroll animations.\n     */\n    attachTimeline(timeline) {\n        if (!this._resolved) {\n            this.pendingTimeline = timeline;\n        }\n        else {\n            const { resolved } = this;\n            if (!resolved)\n                return noop;\n            const { animation } = resolved;\n            animation.timeline = timeline;\n            animation.onfinish = null;\n        }\n        return noop;\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        if (animation.playState === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        animation.play();\n    }\n    pause() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.pause();\n    }\n    stop() {\n        this.resolver.cancel();\n        this.isStopped = true;\n        if (this.state === \"idle\")\n            return;\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation, keyframes, duration, type, ease, times } = resolved;\n        if (animation.playState === \"idle\" ||\n            animation.playState === \"finished\") {\n            return;\n        }\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        if (this.time) {\n            const { motionValue, onUpdate, onComplete, ...options } = this.options;\n            const sampleAnimation = new MainThreadAnimation({\n                ...options,\n                keyframes,\n                duration,\n                type,\n                ease,\n                times,\n                isGenerator: true,\n            });\n            const sampleTime = secondsToMilliseconds(this.time);\n            motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);\n        }\n        this.cancel();\n    }\n    complete() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.finish();\n    }\n    cancel() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.cancel();\n    }\n    static supports(options) {\n        const { motionValue, name, repeatDelay, repeatType, damping, type } = options;\n        return (supportsWaapi() &&\n            name &&\n            acceleratedValues.has(name) &&\n            motionValue &&\n            motionValue.owner &&\n            motionValue.owner.current instanceof HTMLElement &&\n            /**\n             * If we're outputting values to onUpdate then we can't use WAAPI as there's\n             * no way to read the value from WAAPI every frame.\n             */\n            !motionValue.owner.getProps().onUpdate &&\n            !repeatDelay &&\n            repeatType !== \"mirror\" &&\n            damping !== 0 &&\n            type !== \"inertia\");\n    }\n}\n\nexport { AcceleratedAnimation };\n","import { mapEasingToNativeEasing } from './easing.mjs';\n\nfunction animateStyle(element, valueName, keyframes, { delay = 0, duration = 300, 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","import { observeTimeline } from '../render/dom/scroll/observe.mjs';\nimport { supportsScrollTimeline } from '../render/dom/scroll/supports.mjs';\n\nclass GroupPlaybackControls {\n    constructor(animations) {\n        // Bound to accomodate common `return animation.stop` pattern\n        this.stop = () => this.runAll(\"stop\");\n        this.animations = animations.filter(Boolean);\n    }\n    then(onResolve, onReject) {\n        return Promise.all(this.animations).then(onResolve).catch(onReject);\n    }\n    /**\n     * TODO: Filter out cancelled or stopped animations before returning\n     */\n    getAll(propName) {\n        return this.animations[0][propName];\n    }\n    setAll(propName, newValue) {\n        for (let i = 0; i < this.animations.length; i++) {\n            this.animations[i][propName] = newValue;\n        }\n    }\n    attachTimeline(timeline) {\n        const cancelAll = this.animations.map((animation) => {\n            if (supportsScrollTimeline() && animation.attachTimeline) {\n                animation.attachTimeline(timeline);\n            }\n            else {\n                animation.pause();\n                return observeTimeline((progress) => {\n                    animation.time = animation.duration * progress;\n                }, timeline);\n            }\n        });\n        return () => {\n            cancelAll.forEach((cancelTimeline, i) => {\n                if (cancelTimeline)\n                    cancelTimeline();\n                this.animations[i].stop();\n            });\n        };\n    }\n    get time() {\n        return this.getAll(\"time\");\n    }\n    set time(time) {\n        this.setAll(\"time\", time);\n    }\n    get speed() {\n        return this.getAll(\"speed\");\n    }\n    set speed(speed) {\n        this.setAll(\"speed\", speed);\n    }\n    get duration() {\n        let max = 0;\n        for (let i = 0; i < this.animations.length; i++) {\n            max = Math.max(max, this.animations[i].duration);\n        }\n        return max;\n    }\n    runAll(methodName) {\n        this.animations.forEach((controls) => controls[methodName]());\n    }\n    play() {\n        this.runAll(\"play\");\n    }\n    pause() {\n        this.runAll(\"pause\");\n    }\n    cancel() {\n        this.runAll(\"cancel\");\n    }\n    complete() {\n        this.runAll(\"complete\");\n    }\n}\n\nexport { GroupPlaybackControls };\n","import { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getValueTransition, isTransitionDefined } from '../utils/transitions.mjs';\nimport { MotionGlobalConfig } from '../../utils/GlobalConfig.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { getFinalKeyframe } from '../animators/waapi/utils/get-final-keyframe.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\nimport { AcceleratedAnimation } from '../animators/AcceleratedAnimation.mjs';\nimport { MainThreadAnimation } from '../animators/MainThreadAnimation.mjs';\nimport { GroupPlaybackControls } from '../GroupPlaybackControls.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    let options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unqiue transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        options = {\n            ...options,\n            ...getDefaultTransition(name, 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 (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        options.duration = 0;\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (instantAnimationState.current ||\n        MotionGlobalConfig.skipAnimations) {\n        shouldSkip = true;\n        options.duration = 0;\n        options.delay = 0;\n    }\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            // We still want to return some animation controls here rather\n            // than returning undefined\n            return new GroupPlaybackControls([]);\n        }\n    }\n    /**\n     * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via\n     * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n     * optimised animation.\n     */\n    if (!isHandoff && AcceleratedAnimation.supports(options)) {\n        return new AcceleratedAnimation(options);\n    }\n    else {\n        return new MainThreadAnimation(options);\n    }\n};\n\nexport { animateMotionValue };\n","import { animateMotionValue } from './motion-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction animateSingleValue(value, keyframes, options) {\n    const motionValue$1 = isMotionValue(value) ? value : motionValue(value);\n    motionValue$1.start(animateMotionValue(\"\", motionValue$1, keyframes, options));\n    return motionValue$1.animation;\n}\n\nexport { animateSingleValue };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { getValueTransition } from '../utils/transitions.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    var _a;\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;\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, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            elapsed: 0,\n            ...getValueTransition(transition || {}, key),\n        };\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.HandoffAppearAnimations) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const elapsed = window.HandoffAppearAnimations(appearId, key, value, frame);\n                if (elapsed !== null) {\n                    valueTransition.elapsed = elapsed;\n                    isHandoff = true;\n                }\n            }\n        }\n        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n                animation.then(() => willChange.remove(key));\n            }\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        Promise.all(animations).then(() => {\n            frame.update(() => {\n                transitionEnd && setTarget(visualElement, transitionEnd);\n            });\n        });\n    }\n    return animations;\n}\n\nexport { animateTarget };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    var _a;\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n        : undefined);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n\nexport { animateVariant, sortByTreeOrder };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        frame.postRender(() => {\n            visualElement.notify(\"AnimationComplete\", definition);\n        });\n    });\n}\n\nexport { animateVisualElement };\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 { optimizedAppearDataAttribute } from './data-id.mjs';\n\nfunction getOptimisedAppearId(visualElement) {\n    return visualElement.getProps()[optimizedAppearDataAttribute];\n}\n\nexport { getOptimisedAppearId };\n","function isAnimationControls(v) {\n    return (v !== null &&\n        typeof v === \"object\" &&\n        typeof v.start === \"function\");\n}\n\nexport { isAnimationControls };\n","const isKeyframesTarget = (v) => {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\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    else {\n        return true;\n    }\n}\n\nexport { isNone };\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] ||\n        transition[\"default\"] ||\n        transition);\n}\n\nexport { getValueTransition, isTransitionDefined };\n","import { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useRef, useContext, useInsertionEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent }) {\n    const id = useId();\n    const ref = useRef(null);\n    const size = useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n    });\n    const { nonce } = useContext(MotionConfigContext);\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    useInsertionEffect(() => {\n        const { width, height, top, left } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        if (nonce)\n            style.nonce = nonce;\n        document.head.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            top: ${top}px !important;\n            left: ${left}px !important;\n          }\n        `);\n        }\n        return () => {\n            document.head.removeChild(style);\n        };\n    }, [isPresent]);\n    return (jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref }) }));\n}\n\nexport { PopChild };\n","import { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PopChild } from './PopChild.mjs';\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = useId();\n    const context = useMemo(() => ({\n        id,\n        initial,\n        isPresent,\n        custom,\n        onExitComplete: (childId) => {\n            presenceChildren.set(childId, true);\n            for (const isComplete of presenceChildren.values()) {\n                if (!isComplete)\n                    return; // can stop searching when any is incomplete\n            }\n            onExitComplete && onExitComplete();\n        },\n        register: (childId) => {\n            presenceChildren.set(childId, false);\n            return () => presenceChildren.delete(childId);\n        },\n    }), \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? [Math.random()] : [isPresent]);\n    useMemo(() => {\n        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React.useEffect(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = jsx(PopChild, { isPresent: isPresent, children: children });\n    }\n    return (jsx(PresenceContext.Provider, { value: context, children: children }));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n","import { jsx, Fragment } from 'react/jsx-runtime';\nimport { useContext, useRef, cloneElement, Children, isValidElement } from 'react';\nimport { useForceUpdate } from '../../utils/use-force-update.mjs';\nimport { useIsMounted } from '../../utils/use-is-mounted.mjs';\nimport { PresenceChild } from './PresenceChild.mjs';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { useUnmountEffect } from '../../utils/use-unmount-effect.mjs';\nimport { invariant } from '../../utils/errors.mjs';\n\nconst getChildKey = (child) => child.key || \"\";\nfunction updateChildLookup(children, allChildren) {\n    children.forEach((child) => {\n        const key = getChildKey(child);\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    const filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    Children.forEach(children, (child) => {\n        if (isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nconst AnimatePresence = ({ children, custom, initial = true, onExitComplete, exitBeforeEnter, presenceAffectsLayout = true, mode = \"sync\", }) => {\n    invariant(!exitBeforeEnter, \"Replace exitBeforeEnter with mode='wait'\");\n    // We want to force a re-render once all exiting animations have finished. We\n    // either use a local forceRender function, or one from a parent context if it exists.\n    const forceRender = useContext(LayoutGroupContext).forceRender || useForceUpdate()[0];\n    const isMounted = useIsMounted();\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    const filteredChildren = onlyElements(children);\n    let childrenToRender = filteredChildren;\n    const exitingChildren = useRef(new Map()).current;\n    // Keep a living record of the children we're actually rendering so we\n    // can diff to figure out which are entering and exiting\n    const presentChildren = useRef(childrenToRender);\n    // A lookup table to quickly reference components by key\n    const allChildren = useRef(new Map()).current;\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    const isInitialRender = useRef(true);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        updateChildLookup(filteredChildren, allChildren);\n        presentChildren.current = childrenToRender;\n    });\n    useUnmountEffect(() => {\n        isInitialRender.current = true;\n        allChildren.clear();\n        exitingChildren.clear();\n    });\n    if (isInitialRender.current) {\n        return (jsx(Fragment, { children: childrenToRender.map((child) => (jsx(PresenceChild, { isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout, mode: mode, children: child }, getChildKey(child)))) }));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    childrenToRender = [...childrenToRender];\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    const presentKeys = presentChildren.current.map(getChildKey);\n    const targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    const numPresent = presentKeys.length;\n    for (let i = 0; i < numPresent; i++) {\n        const key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1 && !exitingChildren.has(key)) {\n            exitingChildren.set(key, undefined);\n        }\n    }\n    // If we currently have exiting children, and we're deferring rendering incoming children\n    // until after all current children have exiting, empty the childrenToRender array\n    if (mode === \"wait\" && exitingChildren.size) {\n        childrenToRender = [];\n    }\n    // Loop through all currently exiting components and clone them to overwrite `animate`\n    // with any `exit` prop they might have defined.\n    exitingChildren.forEach((component, key) => {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        const child = allChildren.get(key);\n        if (!child)\n            return;\n        const insertionIndex = presentKeys.indexOf(key);\n        let exitingComponent = component;\n        if (!exitingComponent) {\n            const onExit = () => {\n                // clean up the exiting children map\n                exitingChildren.delete(key);\n                // compute the keys of children that were rendered once but are no longer present\n                // this could happen in case of too many fast consequent renderings\n                // @link https://github.com/framer/motion/issues/2023\n                const leftOverKeys = Array.from(allChildren.keys()).filter((childKey) => !targetKeys.includes(childKey));\n                // clean up the all children map\n                leftOverKeys.forEach((leftOverKey) => allChildren.delete(leftOverKey));\n                // make sure to render only the children that are actually visible\n                presentChildren.current = filteredChildren.filter((presentChild) => {\n                    const presentChildKey = getChildKey(presentChild);\n                    return (\n                    // filter out the node exiting\n                    presentChildKey === key ||\n                        // filter out the leftover children\n                        leftOverKeys.includes(presentChildKey));\n                });\n                // Defer re-rendering until all exiting children have indeed left\n                if (!exitingChildren.size) {\n                    if (isMounted.current === false)\n                        return;\n                    forceRender();\n                    onExitComplete && onExitComplete();\n                }\n            };\n            exitingComponent = (jsx(PresenceChild, { isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, children: child }, getChildKey(child)));\n            exitingChildren.set(key, exitingComponent);\n        }\n        childrenToRender.splice(insertionIndex, 0, exitingComponent);\n    });\n    // Add `MotionContext` even to children that don't need it to ensure we're rendering\n    // the same tree between renders\n    childrenToRender = childrenToRender.map((child) => {\n        const key = child.key;\n        return exitingChildren.has(key) ? (child) : (jsx(PresenceChild, { isPresent: true, presenceAffectsLayout: presenceAffectsLayout, mode: mode, children: child }, getChildKey(child)));\n    });\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        childrenToRender.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    return (jsx(Fragment, { children: exitingChildren.size\n            ? childrenToRender\n            : childrenToRender.map((child) => cloneElement(child)) }));\n};\n\nexport { AnimatePresence };\n","import { useContext, useId, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    const context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    const { isPresent, onExitComplete, register } = context;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    const id = useId();\n    useEffect(() => register(id), []);\n    const safeToRemove = () => onExitComplete && onExitComplete(id);\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { createContext } from 'react';\n\nconst LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","import { createContext } from 'react';\n\nconst LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nconst MotionConfigContext = createContext({\n    transformPagePoint: (p) => p,\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","import { useContext, useMemo } from 'react';\nimport { MotionContext } from './index.mjs';\nimport { getCurrentTreeVariants } from './utils.mjs';\n\nfunction useCreateMotionContext(props) {\n    const { initial, animate } = getCurrentTreeVariants(props, useContext(MotionContext));\n    return useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { isVariantLabel } from '../../render/utils/is-variant-label.mjs';\nimport { isControllingVariants } from '../../render/utils/is-controlling-variants.mjs';\n\nfunction getCurrentTreeVariants(props, context) {\n    if (isControllingVariants(props)) {\n        const { initial, animate } = props;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nexport { getCurrentTreeVariants };\n","import { createContext } from 'react';\n\nconst MotionContext = createContext({});\n\nexport { MotionContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nconst PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","import { createContext } from 'react';\n\n/**\n * Internal, exported only for usage in Framer\n */\nconst SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\n"],"names":["underDampedSpring","type","stiffness","damping","restSpeed","keyframesTransition","duration","ease","getDefaultTransition","valueKey","keyframes","length","transform","has","startsWith","Math","sqrt","isNotNull","value","getFinalKeyframe","repeat","repeatType","finalKeyframe","resolvedKeyframes","filter","index","undefined","isAnimatable","name","Array","isArray","complex","test","BaseAnimation","constructor","autoplay","delay","repeatDelay","options","this","isStopped","hasAttemptedResolve","updateFinishedPromise","resolved","_resolved","onKeyframesResolved","velocity","onComplete","onUpdate","isGenerator","originKeyframe","targetKeyframe","isOriginAnimatable","isTargetAnimatable","current","i","hasKeyframesChanged","canAnimate","resolveFinishedPromise","resolvedAnimation","initPlayback","onPostResolved","then","resolve","reject","currentFinishedPromise","Promise","velocitySampleDuration","calcGeneratorVelocity","resolveValue","t","prevT","max","safeMin","minDuration","maxDuration","minDamping","maxDamping","findSpring","bounce","mass","envelope","derivative","dampingRatio","clamp","undampedFreq","exponentialDecay","delta","a","b","calcAngularFreq","c","exp","d","e","pow","f","g","initialGuess","result","rootIterations","approximateRoot","isNaN","durationKeys","physicsKeys","isSpringType","keys","some","key","spring","restDelta","origin","target","state","done","isResolvedFromDuration","springOptions","derived","getSpringOptions","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","abs","resolveSpring","angularFreq","sin","cos","dampedAngularFreq","freqForT","min","sinh","cosh","calculatedDuration","next","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","inertia","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","nearestBoundary","v","amplitude","ideal","calcDelta","calcLatest","applyFriction","latest","timeReachedBoundary","spring$1","checkCatchBoundary","hasUpdatedFrame","keyframeValues","times","easingFunctions","map","absoluteTimes","mapTimeToKeyframe","interpolate","values","easing","splice","frameloopDriver","update","passTimestamp","timestamp","start","stop","now","isProcessing","generators","decay","tween","percentToProgress","percent","MainThreadAnimation","KeyframeResolver","KeyframeResolver$1","super","holdTime","startTime","cancelTime","currentTime","playbackSpeed","pendingPlayState","resolver","cancel","teardown","onStop","motionValue","onResolved","owner","resolveKeyframes","scheduleResolve","keyframes$1","generatorFactory","mapPercentToKeyframes","mirroredGenerator","pipe","mix","generator","reverse","Infinity","calcGeneratorDuration","resolvedDuration","totalDuration","play","pause","tick","sample","speed","round","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","floor","iterationProgress","Boolean","isAnimationFinished","finish","time","newTime","driver","newSpeed","hasChanged","isScheduled","resume","onPlay","_a","complete","stopDriver","isWaapiSupportedEasing","supportedWaapiEasing","every","cubicBezierAsString","linear","easeIn","easeOut","easeInOut","circIn","circOut","backIn","backOut","mapEasingToNativeEasingWithDefault","mapEasingToNativeEasing","supportsWaapi","memo","Object","hasOwnProperty","call","Element","prototype","acceleratedValues","Set","AcceleratedAnimation","DOMKeyframesResolver","pregeneratedAnimation","sampleAnimation","pregeneratedKeyframes","push","pregenerateKeyframes","animation","element","valueName","keyframeOptions","offset","animate","fill","iterations","direction","animateStyle","pendingTimeline","timeline","onfinish","set","playbackRate","playState","attachTimeline","noop","sampleTime","setWithVelocity","supports","HTMLElement","getProps","GroupPlaybackControls","animations","runAll","onResolve","onReject","all","catch","getAll","propName","setAll","newValue","cancelAll","observe","forEach","cancelTimeline","methodName","controls","animateMotionValue","transition","isHandoff","valueTransition","getVelocity","from","shouldSkip","skipAnimations","get","animateSingleValue","motionValue$1","shouldBlockAnimation","protectedKeys","needsAnimating","shouldBlock","animateTarget","visualElement","targetAndTransition","transitionOverride","transitionEnd","willChange","getValue","animationTypeState","animationState","getState","latestValues","valueTarget","window","HandoffAppearAnimations","appearId","shouldReduceMotion","is","add","remove","animateVariant","variant","presenceContext","custom","getAnimation","getChildAnimations","variantChildren","size","forwardDelay","delayChildren","staggerChildren","staggerDirection","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","child","notify","animateChildren","when","first","last","sortNodePosition","animateVisualElement","definition","resolvedDefinition","postRender","optimizedAppearDataAttribute","getOptimisedAppearId","isAnimationControls","isKeyframesTarget","isNone","isTransitionDefined","_delay","getValueTransition","PopChildMeasure","getSnapshotBeforeUpdate","prevProps","props","childRef","isPresent","sizeRef","height","offsetHeight","width","offsetWidth","top","offsetTop","left","offsetLeft","componentDidUpdate","render","children","PopChild","id","useId","ref","useRef","nonce","useContext","MotionConfigContext","useInsertionEffect","dataset","motionPopId","style","document","createElement","head","appendChild","sheet","insertRule","removeChild","jsx","PresenceChild","initial","onExitComplete","presenceAffectsLayout","mode","presenceChildren","newChildrenMap","context","useMemo","childId","isComplete","register","delete","random","_","PresenceContext","Provider","Map","getChildKey","AnimatePresence","exitBeforeEnter","forceRender","LayoutGroupContext","L","isMounted","filteredChildren","filtered","Children","isValidElement","onlyElements","childrenToRender","exitingChildren","presentChildren","allChildren","isInitialRender","updateChildLookup","clear","Fragment","presentKeys","targetKeys","numPresent","indexOf","component","insertionIndex","exitingComponent","onExit","leftOverKeys","childKey","includes","leftOverKey","presentChild","presentChildKey","cloneElement","usePresence","useEffect","createContext","LazyContext","strict","transformPagePoint","p","isStatic","reducedMotion","useCreateMotionContext","inherit","getCurrentTreeVariants","MotionContext","variantLabelsAsDependency","prop","join","SwitchLayoutGroupContext"],"sourceRoot":""}