{"version":3,"file":"3082-ccf44d26c29c8ae5ce7e.js","mappings":"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","sources":["webpack://eploy/./node_modules/popmotion/dist/es/animations/utils/find-spring.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/generators/spring.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/generators/keyframes.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/generators/decay.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/utils/elapsed.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/index.mjs","webpack://eploy/./node_modules/popmotion/dist/es/easing/cubic-bezier.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/animation/utils/easing.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://eploy/./node_modules/popmotion/dist/es/animations/inertia.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/components/LazyMotion/index.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/events/use-dom-event.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/events/utils.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/warn-once.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/index.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/html/visual-element.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/animation.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/types.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/use-id.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://eploy/./node_modules/framesync/dist/es/on-next-frame.mjs","webpack://eploy/./node_modules/framesync/dist/es/index.mjs","webpack://eploy/./node_modules/framesync/dist/es/create-render-step.mjs","webpack://eploy/./node_modules/popmotion/dist/es/easing/utils.mjs","webpack://eploy/./node_modules/popmotion/dist/es/easing/index.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/clamp.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/inc.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/hsla-to-rgba.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/mix-color.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/mix-complex.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/interpolate.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/mix.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/pipe.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/progress.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/velocity-per-second.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/color/hex.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/color/hsla.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/color/index.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/color/rgba.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/color/utils.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/complex/filter.mjs","webpack://eploy/./node_modules/style-value-types/dist/es/complex/index.mjs"],"sourcesContent":["import { warning } from 'hey-listen';\nimport { clamp } from '../../utils/clamp.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 <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\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        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 = duration * 1000;\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 { __rest } from 'tslib';\nimport { findSpring, calcAngularFreq } from '../utils/find-spring.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 = Object.assign({ velocity: 0.0, stiffness: 100, damping: 10, mass: 1.0, isResolvedFromDuration: false }, options);\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = Object.assign(Object.assign(Object.assign({}, springOptions), derived), { velocity: 0.0, mass: 1.0 });\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring(_a) {\n    var { from = 0.0, to = 1.0, restSpeed = 2, restDelta } = _a, options = __rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n    const state = { done: false, value: from };\n    let { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let resolveVelocity = zero;\n    function createSpring() {\n        const initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n        const initialDelta = to - from;\n        const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        if (restDelta === undefined) {\n            restDelta = Math.min(Math.abs(to - from) / 100, 0.4);\n        }\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (to -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n            resolveVelocity = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (dampingRatio *\n                    undampedAngularFreq *\n                    envelope *\n                    ((Math.sin(angularFreq * t) *\n                        (initialVelocity +\n                            dampingRatio *\n                                undampedAngularFreq *\n                                initialDelta)) /\n                        angularFreq +\n                        initialDelta * Math.cos(angularFreq * t)) -\n                    envelope *\n                        (Math.cos(angularFreq * t) *\n                            (initialVelocity +\n                                dampingRatio *\n                                    undampedAngularFreq *\n                                    initialDelta) -\n                            angularFreq *\n                                initialDelta *\n                                Math.sin(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            resolveSpring = (t) => to -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (to -\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    }\n    createSpring();\n    return {\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = resolveVelocity(t) * 1000;\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? to : current;\n            return state;\n        },\n        flipTarget: () => {\n            velocity = -velocity;\n            [from, to] = [to, from];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nexport { spring };\n","import { interpolate } from '../../utils/interpolate.mjs';\nimport { easeInOut } from '../../easing/index.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n    const numValues = values.length;\n    return values.map((_value, i) => i !== 0 ? i / (numValues - 1) : 0);\n}\nfunction convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\nfunction keyframes({ from = 0, to = 1, ease, offset, duration = 300, }) {\n    const state = { done: false, value: from };\n    const values = Array.isArray(to) ? to : [from, to];\n    const times = convertOffsetToTimes(offset && offset.length === values.length\n        ? offset\n        : defaultOffset(values), duration);\n    function createInterpolator() {\n        return interpolate(times, values, {\n            ease: Array.isArray(ease) ? ease : defaultEasing(values, ease),\n        });\n    }\n    let interpolator = createInterpolator();\n    return {\n        next: (t) => {\n            state.value = interpolator(t);\n            state.done = t >= duration;\n            return state;\n        },\n        flipTarget: () => {\n            values.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { convertOffsetToTimes, defaultEasing, defaultOffset, keyframes };\n","import { spring } from '../generators/spring.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { decay } from '../generators/decay.mjs';\n\nconst types = { keyframes, spring, decay };\nfunction detectAnimationFromOptions(config) {\n    if (Array.isArray(config.to)) {\n        return keyframes;\n    }\n    else if (types[config.type]) {\n        return types[config.type];\n    }\n    const keys = new Set(Object.keys(config));\n    if (keys.has(\"ease\") ||\n        (keys.has(\"duration\") && !keys.has(\"dampingRatio\"))) {\n        return keyframes;\n    }\n    else if (keys.has(\"dampingRatio\") ||\n        keys.has(\"stiffness\") ||\n        keys.has(\"mass\") ||\n        keys.has(\"damping\") ||\n        keys.has(\"restSpeed\") ||\n        keys.has(\"restDelta\")) {\n        return spring;\n    }\n    return keyframes;\n}\n\nexport { detectAnimationFromOptions };\n","function decay({ velocity = 0, from = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const state = { done: false, value: from };\n    let amplitude = power * velocity;\n    const ideal = from + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    if (target !== ideal)\n        amplitude = target - from;\n    return {\n        next: (t) => {\n            const delta = -amplitude * Math.exp(-t / timeConstant);\n            state.done = !(delta > restDelta || delta < -restDelta);\n            state.value = state.done ? target : target + delta;\n            return state;\n        },\n        flipTarget: () => { },\n    };\n}\n\nexport { decay };\n","function loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, delay = 0, isForwardPlayback = true) {\n    return isForwardPlayback\n        ? loopElapsed(duration + -elapsed, duration, delay)\n        : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n    return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\n\nexport { hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","import { __rest } from 'tslib';\nimport { detectAnimationFromOptions } from './utils/detect-animation-from-options.mjs';\nimport sync, { cancelSync } from 'framesync';\nimport { interpolate } from '../utils/interpolate.mjs';\nimport { hasRepeatDelayElapsed, reverseElapsed, loopElapsed } from './utils/elapsed.mjs';\n\nconst framesync = (update) => {\n    const passTimestamp = ({ delta }) => update(delta);\n    return {\n        start: () => sync.update(passTimestamp, true),\n        stop: () => cancelSync.update(passTimestamp),\n    };\n};\nfunction animate(_a) {\n    var _b, _c;\n    var { from, autoplay = true, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, onPlay, onStop, onComplete, onRepeat, onUpdate } = _a, options = __rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n    let { to } = options;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = options.duration;\n    let latest;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = detectAnimationFromOptions(options);\n    if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n        interpolateFromNumber = interpolate([0, 100], [from, to], {\n            clamp: false,\n        });\n        from = 0;\n        to = 100;\n    }\n    const animation = animator(Object.assign(Object.assign({}, options), { from, to }));\n    function repeat() {\n        repeatCount++;\n        if (repeatType === \"reverse\") {\n            isForwardPlayback = repeatCount % 2 === 0;\n            elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n        }\n        else {\n            elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n            if (repeatType === \"mirror\")\n                animation.flipTarget();\n        }\n        isComplete = false;\n        onRepeat && onRepeat();\n    }\n    function complete() {\n        driverControls.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            const state = animation.next(Math.max(0, elapsed));\n            latest = state.value;\n            if (interpolateFromNumber)\n                latest = interpolateFromNumber(latest);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n        if (isComplete) {\n            if (repeatCount === 0)\n                computedDuration !== null && computedDuration !== void 0 ? computedDuration : (computedDuration = elapsed);\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop === null || onStop === void 0 ? void 0 : onStop();\n            driverControls.stop();\n        },\n    };\n}\n\nexport { animate };\n","import { linear } from './index.mjs';\n\nconst a = (a1, a2) => 1.0 - 3.0 * a2 + 3.0 * a1;\nconst b = (a1, a2) => 3.0 * a2 - 6.0 * a1;\nconst c = (a1) => 3.0 * a1;\nconst calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\nconst getSlope = (t, a1, a2) => 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = aA + (aB - aA) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - aX;\n        if (currentX > 0.0) {\n            aB = currentT;\n        }\n        else {\n            aA = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nconst newtonIterations = 8;\nconst newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n    for (let i = 0; i < newtonIterations; ++i) {\n        const currentSlope = getSlope(aGuessT, mX1, mX2);\n        if (currentSlope === 0.0) {\n            return aGuessT;\n        }\n        const currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n        aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n}\nconst kSplineTableSize = 11;\nconst kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    if (mX1 === mY1 && mX2 === mY2)\n        return linear;\n    const sampleValues = new Float32Array(kSplineTableSize);\n    for (let i = 0; i < kSplineTableSize; ++i) {\n        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n    }\n    function getTForX(aX) {\n        let intervalStart = 0.0;\n        let currentSample = 1;\n        const lastSample = kSplineTableSize - 1;\n        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        const dist = (aX - sampleValues[currentSample]) /\n            (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n        const guessForT = intervalStart + dist * kSampleStepSize;\n        const initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= newtonMinSlope) {\n            return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n        }\n        else if (initialSlope === 0.0) {\n            return guessForT;\n        }\n        else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n        }\n    }\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { cubicBezier, linear, easeIn, easeInOut, easeOut, circIn, circInOut, circOut, backIn, backInOut, backOut, anticipate, bounceIn, bounceInOut, bounceOut } from 'popmotion';\n\nvar easingLookup = {\n    linear: linear,\n    easeIn: easeIn,\n    easeInOut: easeInOut,\n    easeOut: easeOut,\n    circIn: circIn,\n    circInOut: circInOut,\n    circOut: circOut,\n    backIn: backIn,\n    backInOut: backInOut,\n    backOut: backOut,\n    anticipate: anticipate,\n    bounceIn: bounceIn,\n    bounceInOut: bounceInOut,\n    bounceOut: bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = __read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\".concat(definition, \"'\"));\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { easingDefinitionToFunction, isEasingArray };\n","import { complex } from 'style-value-types';\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 */\nvar isAnimatable = function (key, value) {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        complex.test(value) && // 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 { __assign } from 'tslib';\nimport { isKeyframesTarget } from './is-keyframes-target.mjs';\n\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\n}); };\nvar defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return __assign({ to: to }, transitionFactory(to));\n};\n\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };\n","var instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","import { __assign, __rest, __spreadArray, __read } from 'tslib';\nimport { inertia, animate } from 'popmotion';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { isEasingArray, easingDefinitionToFunction } from './easing.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { getDefaultTransition } from './default-transitions.mjs';\nimport { warning } from 'hey-listen';\nimport { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\n\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(_a) {\n    _a.when; _a.delay; _a.delayChildren; _a.staggerChildren; _a.staggerDirection; _a.repeat; _a.repeatType; _a.repeatDelay; _a.from; var transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n    return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n    var ease = _a.ease, times = _a.times, yoyo = _a.yoyo, flip = _a.flip, loop = _a.loop, transition = __rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = __assign({}, transition);\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a, _b;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = __spreadArray([], __read(options.to), false);\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = __assign(__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return __assign(__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key);\n    var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n    var isTargetAnimatable = isAnimatable(key, target);\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(key, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    var isOriginAnimatable = isAnimatable(key, origin);\n    warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \".concat(key, \" from \\\"\").concat(origin, \"\\\" to \\\"\").concat(target, \"\\\". \").concat(origin, \" is not an animatable value - to enable this animation set \").concat(origin, \" to a value animatable to \").concat(target, \" via the `style` property.\"));\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? inertia(__assign(__assign({}, options), valueTransition))\n            : animate(__assign(__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: function (v) {\n                    var _a;\n                    options.onUpdate(v);\n                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n                }, onComplete: function () {\n                    var _a;\n                    options.onComplete();\n                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n                } }));\n    }\n    function set() {\n        var _a, _b;\n        var finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);\n        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = window.setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\n}\n\nexport { convertTransitionToAnimationOptions, getDelayFromTransition, getPopmotionAnimationOptions, getValueTransition, getZeroUnit, hydrateKeyframes, isTransitionDefined, isZero, startAnimation };\n","import { animate } from './index.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { getFrameData } from 'framesync';\n\nfunction inertia({ from = 0, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function boundaryNearest(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    function startAnimation(options) {\n        currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate(Object.assign(Object.assign({}, options), { driver, onUpdate: (v) => {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            }, onComplete,\n            onStop }));\n    }\n    function startSpring(options) {\n        startAnimation(Object.assign({ type: \"spring\", stiffness: bounceStiffness, damping: bounceDamping, restDelta }, options));\n    }\n    if (isOutOfBounds(from)) {\n        startSpring({ from, velocity, to: boundaryNearest(from) });\n    }\n    else {\n        let target = power * velocity + from;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = boundaryNearest(target);\n        const heading = boundary === min ? -1 : 1;\n        let prev;\n        let current;\n        const checkBoundary = (v) => {\n            prev = current;\n            current = v;\n            velocity = velocityPerSecond(v - prev, getFrameData().delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ from: v, to: boundary, velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            from,\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","import { useContext, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useId } from '../../utils/use-id.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    var context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\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    // Replace with useId when released in React\n    var id = useId();\n    useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : 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 { __read, __rest } from 'tslib';\nimport * as React from 'react';\nimport { useState, useRef, useEffect } from 'react';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { loadFeatures } from '../../motion/features/definitions.mjs';\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = __read(useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = __rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = __rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\nexport { LazyMotion };\n","import { isTouchEvent } from '../gestures/utils/event-type.mjs';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, wrapHandler };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","import { isBrowser } from '../utils/is-browser.mjs';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nexport { addPointerEvent, usePointerEvent };\n","function createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","function isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\nexport { isMouseEvent, isTouchEvent };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    var distanceFromOrigin = point - originPoint;\n    var scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys);\n    transformAxis(box.y, transform, yKeys);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { hasScale, hasTransform };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","import { __spreadArray, __read, __assign, __rest } from 'tslib';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { AnimationType } from './types.mjs';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.mjs';\n\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = __rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = __assign(__assign(__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\n    }\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        var animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        var removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        var encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            var activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = __assign({}, encounteredKeys);\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                return \"continue\";\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            var variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = __assign(__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = __assign(__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, __spreadArray([], __read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: __assign({ type: type }, options),\n                }); })), false));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = __assign({}, encounteredKeys);\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[AnimationType.Animate] = createTypeState(true),\n        _a[AnimationType.InView] = createTypeState(),\n        _a[AnimationType.Hover] = createTypeState(),\n        _a[AnimationType.Tap] = createTypeState(),\n        _a[AnimationType.Drag] = createTypeState(),\n        _a[AnimationType.Focus] = createTypeState(),\n        _a[AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nexport { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { createAnimationState } from '../../render/utils/animation-state.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","import { isMouseEvent } from './utils/event-type.mjs';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\nexport { useHoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","var warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n","import { __rest, __assign } from 'tslib';\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = __rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, __assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { env } from '../../../utils/process.mjs';\nimport { useRef, useEffect } from 'react';\nimport { AnimationType } from '../../../render/utils/types.mjs';\nimport { warnOnce } from '../../../utils/warn-once.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nexport { useViewport };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.mjs';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.mjs';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.mjs';\nimport { useViewport } from './viewport/use-viewport.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === number || v === px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (key) {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = __assign({}, target);\n    transitionEnd = __assign({}, transitionEnd);\n    var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var fromType = findDimensionValueType(from);\n        var to = target[key];\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                var current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = __read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\nexport { BoundingBoxDimension, positionalValues, unitConversion };\n","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = useRef(false);\n    var cancelPointerEndListeners = useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.mjs';\nimport { useDomEvent } from '../events/use-dom-event.mjs';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nexport { useFocusGesture };\n","import { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, __spreadArray([], __read(args), false));\n        };\n    });\n    return lifecycles;\n}\n\nexport { createLifecycles };\n","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { createLifecycles } from './utils/lifecycles.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.mjs';\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = __assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync.update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = __assign(__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                cancelSync.update(update);\n                cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            }, \n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\n            }, \n            /**\n             * Measure the current viewport box with or without transforms.\n             * Only measures axis-aligned boxes, rotate and skew must be manually\n             * removed with a re-render to work.\n             */\n            measureViewportBox: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \n            /**\n             * If we're trying to animate to a previously unencountered value,\n             * we need to check for it in our state and as a last resort read it\n             * directly from the instance (which might have performance implications).\n             */\n            readValue: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n            }, \n            /**\n             * Set the base target to later animate back to. This is currently\n             * only hydrated on creation and when we first read a value.\n             */\n            setBaseTarget: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync.render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \n            /**\n             * Update the provided props. Ensure any newly-added motion values are\n             * added to our map, old ones removed, and listeners updated.\n             */\n            setProps: function (newProps) {\n                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nexport { visualElement };\n","import { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs';\nimport { isTransformProp } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle(domElement);\n            return ((isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    },\n    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return __assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n","import { __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { htmlConfig } from '../html/visual-element.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\n\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nexport { svgVisualElement };\n","import { __assign } from 'tslib';\nimport { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nvar domAnimation = __assign(__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\nexport { domAnimation };\n","import { htmlVisualElement } from '../html/visual-element.mjs';\nimport { svgVisualElement } from '../svg/visual-element.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { __rest, __assign, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = __read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\".concat(current, \"\\\". This may indicate a circular fallback dependency.\"));\n    var _a = __read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = __rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof Element))\n        return { target: target, transitionEnd: transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = __assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","import { filter, complex } from 'style-value-types';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nexport { getAnimatableNone };\n","import { __assign } from 'tslib';\nimport { color, filter } from 'style-value-types';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = __assign(__assign({}, numberValueTypes), { \n    // Color props\n    color: color, backgroundColor: color, outlineColor: color, fill: color, stroke: color, \n    // Border props\n    borderColor: color, borderTopColor: color, borderRightColor: color, borderBottomColor: color, borderLeftColor: color, filter: filter, WebkitFilter: filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nexport { defaultValueTypes, getDefaultValueType };\n","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\nexport { auto };\n","/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\nexport { testValueType };\n","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { setTarget } from './setters.mjs';\nimport { resolveVariant } from './variants.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\n\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\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    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return 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    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return 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    var when = transition.when;\n    if (when) {\n        var _c = __read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = __rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var valueTransition = __assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = __assign(__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, __assign(__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\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(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nexport { isZeroValueString };\n","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes), false), [color, complex], false);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\n\nexport { findValueType };\n","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = __rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = __assign(__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = __spreadArray([], __read(variantLabels), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","var AnimationType;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\n","import { __read } from 'tslib';\n\nfunction addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_a, fromIndex, toIndex) {\n    var _b = __read(_a), arr = _b.slice(0);\n    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        var _c = __read(arr.splice(fromIndex, 1), 1), item = _c[0];\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (var i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nexport { SubscriptionManager };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) { return seconds * 1000; };\n\nexport { secondsToMilliseconds };\n","import { useConstant } from './use-constant.mjs';\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\nexport { useId };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\n","import sync, { getFrameData } from 'framesync';\nimport { velocityPerSecond } from 'popmotion';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    function MotionValue(init) {\n        var _this = this;\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"6.5.1\";\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync.postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.notify(_this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = function () { return sync.postRender(_this.velocityCheck); };\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @privateRemarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\n    };\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\n        return this.prev;\n    };\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\n    };\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\n    };\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\nexport { MotionValue, motionValue };\n","const defaultTimestep = (1 / 60) * 1000;\nconst getCurrentTime = typeof performance !== \"undefined\"\n    ? () => performance.now()\n    : () => Date.now();\nconst onNextFrame = typeof window !== \"undefined\"\n    ? (callback) => window.requestAnimationFrame(callback)\n    : (callback) => setTimeout(() => callback(getCurrentTime()), defaultTimestep);\n\nexport { defaultTimestep, onNextFrame };\n","import { onNextFrame, defaultTimestep } from './on-next-frame.mjs';\nimport { createRenderStep } from './create-render-step.mjs';\n\nconst maxElapsed = 40;\nlet useDefaultElapsed = true;\nlet runNextFrame = false;\nlet isProcessing = false;\nconst frame = {\n    delta: 0,\n    timestamp: 0,\n};\nconst stepsOrder = [\n    \"read\",\n    \"update\",\n    \"preRender\",\n    \"render\",\n    \"postRender\",\n];\nconst steps = stepsOrder.reduce((acc, key) => {\n    acc[key] = createRenderStep(() => (runNextFrame = true));\n    return acc;\n}, {});\nconst sync = stepsOrder.reduce((acc, key) => {\n    const step = steps[key];\n    acc[key] = (process, keepAlive = false, immediate = false) => {\n        if (!runNextFrame)\n            startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nconst cancelSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nconst flushSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = () => steps[key].process(frame);\n    return acc;\n}, {});\nconst processStep = (stepId) => steps[stepId].process(frame);\nconst processFrame = (timestamp) => {\n    runNextFrame = false;\n    frame.delta = useDefaultElapsed\n        ? defaultTimestep\n        : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n    frame.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nconst startLoop = () => {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing)\n        onNextFrame(processFrame);\n};\nconst getFrameData = () => frame;\n\nexport default sync;\nexport { cancelSync, flushSync, getFrameData };\n","function createRenderStep(runNextFrame) {\n    let toRun = [];\n    let toRunNextFrame = [];\n    let numToRun = 0;\n    let isProcessing = false;\n    let flushNextFrame = false;\n    const toKeepAlive = new WeakSet();\n    const step = {\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        cancel: (callback) => {\n            const index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        process: (frameData) => {\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [toRun, toRunNextFrame] = [toRunNextFrame, toRun];\n            toRunNextFrame.length = 0;\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","const reverseEasing = easing => p => 1 - easing(1 - p);\nconst mirrorEasing = easing => p => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\nconst createExpoIn = (power) => p => Math.pow(p, power);\nconst createBackIn = (power) => p => p * p * ((power + 1) * p - power);\nconst createAnticipate = (power) => {\n    const backEasing = createBackIn(power);\n    return p => (p *= 2) < 1\n        ? 0.5 * backEasing(p)\n        : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n};\n\nexport { createAnticipate, createBackIn, createExpoIn, mirrorEasing, reverseEasing };\n","import { createExpoIn, reverseEasing, mirrorEasing, createBackIn, createAnticipate } from './utils.mjs';\n\nconst DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nconst BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nconst BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nconst BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nconst linear = p => p;\nconst easeIn = createExpoIn(2);\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\nconst circIn = p => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\nconst backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nconst backOut = reverseEasing(backIn);\nconst backInOut = mirrorEasing(backIn);\nconst anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nconst ca = 4356.0 / 361.0;\nconst cb = 35442.0 / 1805.0;\nconst cc = 16061.0 / 1805.0;\nconst bounceOut = (p) => {\n    if (p === 1 || p === 0)\n        return p;\n    const p2 = p * p;\n    return p < BOUNCE_FIRST_THRESHOLD\n        ? 7.5625 * p2\n        : p < BOUNCE_SECOND_THRESHOLD\n            ? 9.075 * p2 - 9.9 * p + 3.4\n            : p < BOUNCE_THIRD_THRESHOLD\n                ? ca * p2 - cb * p + cc\n                : 10.8 * p * p - 20.52 * p + 10.72;\n};\nconst bounceIn = reverseEasing(bounceOut);\nconst bounceInOut = (p) => p < 0.5\n    ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0))\n    : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n\nexport { anticipate, backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, easeIn, easeInOut, easeOut, linear };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","const zeroPoint = {\n    x: 0,\n    y: 0,\n    z: 0\n};\nconst isNum = (v) => typeof v === 'number';\n\nexport { isNum, zeroPoint };\n","function hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","import { mix } from './mix.mjs';\nimport { hsla, rgba, hex } from 'style-value-types';\nimport { invariant } from 'hey-listen';\nimport { hslaToRgba } from './hsla-to-rgba.mjs';\n\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const toExpo = to * to;\n    return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nconst notAnimatable = (color) => `'${color}' is not an animatable color. Use the equivalent color code instead.`;\nconst mixColor = (from, to) => {\n    let fromColorType = getColorType(from);\n    let toColorType = getColorType(to);\n    invariant(!!fromColorType, notAnimatable(from));\n    invariant(!!toColorType, notAnimatable(to));\n    let fromColor = fromColorType.parse(from);\n    let toColor = toColorType.parse(to);\n    if (fromColorType === hsla) {\n        fromColor = hslaToRgba(fromColor);\n        fromColorType = rgba;\n    }\n    if (toColorType === hsla) {\n        toColor = hslaToRgba(toColor);\n        toColorType = rgba;\n    }\n    const blended = Object.assign({}, fromColor);\n    return (v) => {\n        for (const key in blended) {\n            if (key !== \"alpha\") {\n                blended[key] = mixLinearColor(fromColor[key], toColor[key], v);\n            }\n        }\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n        return fromColorType.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","import { complex, color } from 'style-value-types';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { isNum } from './inc.mjs';\nimport { pipe } from './pipe.mjs';\nimport { warning } from 'hey-listen';\n\nfunction getMixer(origin, target) {\n    if (isNum(origin)) {\n        return (v) => mix(origin, target, v);\n    }\n    else if (color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return mixComplex(origin, target);\n    }\n}\nconst mixArray = (from, to) => {\n    const output = [...from];\n    const numValues = output.length;\n    const blendValue = from.map((fromThis, i) => getMixer(fromThis, to[i]));\n    return (v) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](v);\n        }\n        return output;\n    };\n};\nconst mixObject = (origin, target) => {\n    const output = Object.assign(Object.assign({}, origin), target);\n    const blendValue = {};\n    for (const key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(origin[key], target[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n};\nfunction analyse(value) {\n    const parsed = complex.parse(value);\n    const numValues = parsed.length;\n    let numNumbers = 0;\n    let numRGB = 0;\n    let numHSL = 0;\n    for (let i = 0; i < numValues; i++) {\n        if (numNumbers || typeof parsed[i] === \"number\") {\n            numNumbers++;\n        }\n        else {\n            if (parsed[i].hue !== undefined) {\n                numHSL++;\n            }\n            else {\n                numRGB++;\n            }\n        }\n    }\n    return { parsed, numNumbers, numRGB, numHSL };\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyse(origin);\n    const targetStats = analyse(target);\n    const canInterpolate = originStats.numHSL === targetStats.numHSL &&\n        originStats.numRGB === targetStats.numRGB &&\n        originStats.numNumbers >= targetStats.numNumbers;\n    if (canInterpolate) {\n        return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return (p) => `${p > 0 ? target : origin}`;\n    }\n};\n\nexport { mixArray, mixComplex, mixObject };\n","import { progress } from './progress.mjs';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.mjs';\nimport { color } from 'style-value-types';\nimport { clamp } from './clamp.mjs';\nimport { pipe } from './pipe.mjs';\nimport { invariant } from 'hey-listen';\n\nconst mixNumber = (from, to) => (p) => mix(from, to, p);\nfunction detectMixerFactory(v) {\n    if (typeof v === 'number') {\n        return mixNumber;\n    }\n    else if (typeof v === 'string') {\n        if (color.test(v)) {\n            return mixColor;\n        }\n        else {\n            return mixComplex;\n        }\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === 'object') {\n        return mixObject;\n    }\n}\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || detectMixerFactory(output[0]);\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\nfunction fastInterpolate([from, to], [mixer]) {\n    return (v) => mixer(progress(from, to, v));\n}\nfunction slowInterpolate(input, mixers) {\n    const inputLength = input.length;\n    const lastInputIndex = inputLength - 1;\n    return (v) => {\n        let mixerIndex = 0;\n        let foundMixerIndex = false;\n        if (v <= input[0]) {\n            foundMixerIndex = true;\n        }\n        else if (v >= input[lastInputIndex]) {\n            mixerIndex = lastInputIndex - 1;\n            foundMixerIndex = true;\n        }\n        if (!foundMixerIndex) {\n            let i = 1;\n            for (; i < inputLength; i++) {\n                if (input[i] > v || i === lastInputIndex) {\n                    break;\n                }\n            }\n            mixerIndex = i - 1;\n        }\n        const progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n        return mixers[mixerIndex](progressInRange);\n    };\n}\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n    invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n    if (input[0] > input[inputLength - 1]) {\n        input = [].concat(input);\n        output = [].concat(output);\n        input.reverse();\n        output.reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const interpolator = inputLength === 2\n        ? fastInterpolate(input, mixers)\n        : slowInterpolate(input, mixers);\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","const mix = (from, to, progress) => -progress * from + progress * to + from;\n\nexport { mix };\n","const combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","const progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","function velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = '';\n    let g = '';\n    let b = '';\n    let a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nexport { hsla };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { number, alpha } from '../numbers/index.mjs';\nimport { sanitize, clamp } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = clamp(0, 255);\nconst rgbUnit = Object.assign(Object.assign({}, number), { transform: (v) => Math.round(clampRgbUnit(v)) });\nconst rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => 'rgba(' +\n        rgbUnit.transform(red) +\n        ', ' +\n        rgbUnit.transform(green) +\n        ', ' +\n        rgbUnit.transform(blue) +\n        ', ' +\n        sanitize(alpha.transform(alpha$1)) +\n        ')',\n};\n\nexport { rgbUnit, rgba };\n","import { isString, singleColorRegex, floatRegex } from '../utils.mjs';\n\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\nconst maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    let [name, value] = v.slice(0, -1).split('(');\n    if (name === 'drop-shadow')\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, '');\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + '(' + defaultValue + unit + ')';\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = Object.assign(Object.assign({}, complex), { getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexport { filter };\n","import { color } from '../color/index.mjs';\nimport { number } from '../numbers/index.mjs';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.mjs';\n\nconst colorToken = '${c}';\nconst numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    if (typeof v === 'number')\n        v = `${v}`;\n    const values = [];\n    let numColors = 0;\n    const colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push(...colors.map(color.parse));\n    }\n    const numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push(...numbers.map(number.parse));\n    }\n    return { values, numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    const { values, numColors, tokenised } = analyse(v);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === 'number' ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parse(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = { test, parse, createTransformer, getAnimatableNone };\n\nexport { complex };\n"],"names":["safeMin","minDuration","maxDuration","minDamping","maxDamping","rootIterations","calcAngularFreq","undampedFreq","dampingRatio","Math","sqrt","durationKeys","physicsKeys","isSpringType","options","keys","some","key","undefined","spring","_a","from","to","restSpeed","restDelta","state","done","value","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","springOptions","Object","assign","derived","bounce","envelope","derivative","clamp","exponentialDecay","delta","a","b","c","exp","d","e","pow","f","g","initialGuess","result","i","approximateRoot","isNaN","findSpring","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","min","abs","angularFreq","t","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","next","current","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","defaultEasing","values","easing","map","splice","length","keyframes","ease","offset","Array","isArray","times","o","convertOffsetToTimes","numValues","_value","defaultOffset","createInterpolator","interpolate","interpolator","reverse","types","power","timeConstant","modifyTarget","amplitude","ideal","target","loopElapsed","elapsed","delay","framesync","update","passTimestamp","start","stop","animate","_b","_c","autoplay","driver","repeat","repeatMax","repeatType","repeatDelay","onPlay","onStop","onComplete","onRepeat","onUpdate","driverControls","latest","interpolateFromNumber","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","config","type","Set","has","detectAnimationFromOptions","call","animation","max","hasRepeatDelayElapsed","reverseElapsed","a1","a2","calcBezier","getSlope","kSampleStepSize","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","Float32Array","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","getTForX","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","definition","concat","isEasingArray","isAnimatable","complex","test","startsWith","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","x","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","color","default","getDefaultTransition","valueKey","transitionFactory","instantAnimationState","legacyRepeatWarning","getAnimation","transition","valueTransition","getValueTransition","origin","get","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","getVelocity","v","set","bounceStiffness","bounceDamping","currentAnimation","isOutOfBounds","boundaryNearest","startAnimation","startSpring","boundary","heading","prev","checkBoundary","inertia","hydrateKeyframes","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","yoyo","flip","loop","convertTransitionToAnimationOptions","getPopmotionAnimationOptions","finalTarget","parseFloat","indexOf","potentialUnitType","delayTimer","controls","getDelayFromTransition","window","setTimeout","clearTimeout","usePresence","context","useContext","isPresent","onExitComplete","register","id","useEffect","LazyMotion","children","features","strict","setIsLoaded","useState","isLazyBundle","loadedRenderer","useRef","renderer","loadedFeatures","then","Provider","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","point","touches","changedTouches","pointFromMouse","extractEventInfo","event","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","isMouseEvent","MouseEvent","button","addDomEvent","eventName","passive","addEventListener","removeEventListener","useDomEvent","ref","element","supportsPointerEvents","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","PointerEvent","pointerType","isTouchEvent","makeRenderlessComponent","hook","props","convertBoundingBoxToBox","top","left","right","bottom","convertBoxToBoundingBox","transformBoxPoints","transformPoint","topLeft","bottomRight","scalePoint","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","node","projectionDelta","instance","style","display","layoutScroll","scroll","root","transformBox","latestValues","translateAxis","distance","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","transform","isIdentityScale","hasScale","hasTransform","hasTranslate","measureViewportBox","getBoundingClientRect","measurePageBox","rootProjectionNode","transformPagePoint","viewportBox","shallowCompare","prevLength","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Drag","Exit","reversePriorityOrder","numAnimationTypes","createTypeState","isActive","protectedKeys","needsAnimating","prevResolvedValues","animations","visualElement","animationState","Promise","all","animateList","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","resolved","transitionEnd","animateChanges","changedActiveType","getProps","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","prop","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","allKeys","markToAnimate","delete","hasOwnProperty","add","blockInitialAnimation","push","apply","size","fallbackAnimation_1","forEach","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","initial","resolve","isAnimated","setActive","variantChildren","child","setAnimateFunction","makeAnimator","getState","createAnimationState","subscribe","exit","custom","safeToRemove","presenceContext","PresenceContext","createHoverEvent","callback","info","isNodeOrChild","parent","parentElement","warned","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","thresholdNames","useIntersectionObserver","shouldObserve","rootMargin","margin","amount","once","threshold","rootInteresectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","observeIntersection","getInstance","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","fallback","message","console","warn","requestAnimationFrame","BoundingBoxDimension","gestureAnimations","inView","whileInView","viewport","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","onPointerUp","onPointerCancel","pipe","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","names","treeType","build","makeTargetAnimatable","renderInstance","render","readValueFromInstance","removeValueFromRenderState","sortNodePosition","scrapeMotionValuesFromProps","presenceId","visualState","shouldReduceMotion","removeFromVariantTree","isMounted","renderState","lifecycles","managers","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","_i","arguments","notify","createLifecycles","Map","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","projection","notifyUpdate","bindToMotionValue","removeOnChange","onChange","latestValue","removeOnRenderRequest","onRenderRequest","scheduleRender","initialMotionValues","isControllingVariants","isVariantNode","depth","isVisible","mount","newInstance","addVariantChild","setProps","unmount","remove","closestVariantNode","getClosestVariantNode","other","getLayoutId","layoutId","getStaticValue","setStaticValue","getLatestValues","setVisibility","visibility","canMutate","addValue","hasValue","removeValue","getValue","defaultValue","forEachValue","readValue","setBaseTarget","syncRender","newProps","transformTemplate","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","getVariant","variants","getTransformPagePoint","startAtParent","context_1","numVariantProps","name_1","variantProps","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","px","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","match","transformKeys","nonTranslationalTransformKeys","filter","positionalValues","width","paddingLeft","_d","paddingRight","height","paddingTop","paddingBottom","unitConversion","hasPositionalKey","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY_1","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","getComputedStyle","targetBbox","convertChangedValueTypes","scrollTo","checkAndConvertChangedValueTypes","htmlConfig","domElement","defaultType","computedStyle","getPropertyValue","compareDocumentPosition","measure","m","resetTransform","restoreTransform","mutableState","vars","transformValues","parsed","parseDomVariant","htmlVisualElement","svgVisualElement","getAttribute","_element","domAnimation","Component","enableHardwareAcceleration","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","exec","parseCSSVariable","token","trim","resolveCSSVariables","Element","getAnimatableNone","defaultValueType","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","dimensionValueTypes","vw","vh","parse","findDimensionValueType","find","testValueType","animateVisualElement","notifyAnimationStart","variant","animateVariant","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getChildAnimations","forwardDelay","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","animateChildren","first","last","_e","_f","animationTypeState","valueTarget","shouldBlockAnimation","stopAnimation","shouldBlock","isNumericalString","isZeroValueString","valueTypes","findValueType","setMotionValue","setTarget","setVariants","variantLabels","setValues","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","getOriginFromTransition","getOrigin","AnimationType","addUniqueItem","arr","item","removeItem","index","SubscriptionManager","this","subscriptions","prototype","_this","numSubscriptions","getSize","secondsToMilliseconds","seconds","counter","incrementId","useId","useUnmountEffect","MotionValue","init","version","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","timestamp","postRender","scheduleVelocityCheck","velocityCheck","subscription","clearListeners","attach","passiveEffect","getPrevious","clearAnimation","isAnimating","destroy","motionValue","defaultTimestep","getCurrentTime","performance","now","Date","onNextFrame","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","cancel","process","frameData","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","getFrameData","reverseEasing","p","mirrorEasing","createBackIn","BOUNCE_FIRST_THRESHOLD","BOUNCE_SECOND_THRESHOLD","acos","backEasing","createAnticipate","ca","cb","cc","p2","isNum","hueToRgb","q","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","round","mixLinearColor","fromExpo","toExpo","colorTypes","hex","rgba","hsla","getColorType","notAnimatable","mixColor","fromColorType","toColorType","fromColor","toColor","blended","mix","getMixer","mixComplex","mixArray","output","blendValue","fromThis","mixObject","analyse","numNumbers","numRGB","numHSL","template","createTransformer","originStats","targetStats","mixNumber","input","isClamp","mixer","inputLength","mixers","customMixer","mixerFactory","numMixers","easingFunction","createMixers","progress","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","combineFunctions","transformers","toFromDifference","velocityPerSecond","frameDuration","r","substr","parseInt","alpha$1","clampRgbUnit","rgbUnit","isColorString","testProp","splitColor","aName","bName","cName","maxDefaults","applyDefaultFilter","slice","number","unit","replace","functionRegex","functions","join","colorToken","numberToken","numColors","colors","numbers","tokenised","convertNumbersToZero","transformer"],"sourceRoot":""}