{"version":3,"file":"4434-398538468d09ef208115.js","mappings":"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","sources":["webpack://tipton/./node_modules/popmotion/dist/es/animations/utils/find-spring.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/generators/spring.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/hsla-to-rgba.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/mix-color.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/mix-complex.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/interpolate.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/generators/keyframes.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/generators/decay.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/utils/elapsed.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/index.mjs","webpack://tipton/./node_modules/popmotion/dist/es/easing/cubic-bezier.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/animation/utils/easing.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://tipton/./node_modules/popmotion/dist/es/animations/inertia.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/components/LazyMotion/index.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/events/use-dom-event.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/events/utils.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/distance.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/PanSession.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/types.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/warn-once.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/index.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/visual-element.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/features-max.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/animation.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/use-id.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://tipton/./node_modules/framesync/dist/es/on-next-frame.mjs","webpack://tipton/./node_modules/framesync/dist/es/index.mjs","webpack://tipton/./node_modules/framesync/dist/es/create-render-step.mjs","webpack://tipton/./node_modules/popmotion/dist/es/easing/utils.mjs","webpack://tipton/./node_modules/popmotion/dist/es/easing/index.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/clamp.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/inc.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/mix.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/pipe.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/progress.mjs","webpack://tipton/./node_modules/popmotion/dist/es/utils/velocity-per-second.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/color/hex.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/color/hsla.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/color/index.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/color/rgba.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/color/utils.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/complex/filter.mjs","webpack://tipton/./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","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","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 { __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","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","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","const isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nexport { isPoint };\n","import { isPoint } from './is-point.mjs';\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.mjs';\nimport { isPoint3D } from './is-point-3d.mjs';\nimport { isNum } from './inc.mjs';\n\nconst distance1D = (a, b) => Math.abs(a - b);\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        const xDelta = distance1D(a.x, b.x);\n        const yDelta = distance1D(a.y, b.y);\n        const zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nexport { distance };\n","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\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","import { mix, distance } from 'popmotion';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = __read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\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","var createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\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","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 { __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","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","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = __assign(__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return __assign(__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","import { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = useRef(null);\n    var transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\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 { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\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 { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(__assign(__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\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 { mix, progress, linear, circOut } from 'popmotion';\nimport { px, percent } from 'style-value-types';\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, linear);\nfunction compress(min, max, easing) {\n    return function (p) {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\n","/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\nexport { copyAxisInto, copyBoxInto };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { scalePoint } from './delta-apply.mjs';\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a, origin, sourceAxis) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\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 * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","function isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nexport { boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nexport { NodeStack };\n","var identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nexport { buildProjectionTransform, identityProjection };\n","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\nexport { FlatTree };\n","import { __spreadArray, __read, __assign } from 'tslib';\nimport sync, { cancelSync, flushSync } from 'framesync';\nimport { mix } from 'popmotion';\nimport { animate } from '../../animation/animate.mjs';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEquals, isDeltaZero } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale } from '../utils/has-transform.mjs';\nimport { transformAxes } from '../../render/html/utils/transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\n\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? __spreadArray(__spreadArray([], __read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, __spreadArray([], __read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = __assign(__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync.preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync.postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = __assign(__assign(__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = __assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync.update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, __assign(__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = mix(delta.translate, 0, p);\n    output.scale = mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = mix(from.min, to.min, p);\n    output.max = mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nexport { createProjectionNode, mixAxis, mixAxisDelta, mixBox };\n","import { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { startAnimation } from './utils/transitions.mjs';\n\n/**\n * Animate a single value or a `MotionValue`.\n *\n * The first argument is either a `MotionValue` to animate, or an initial animation value.\n *\n * The second is either a value to animate to, or an array of keyframes to animate through.\n *\n * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.\n *\n * Returns `AnimationPlaybackControls`, currently just a `stop` method.\n *\n * ```javascript\n * const x = useMotionValue(0)\n *\n * useEffect(() => {\n *   const controls = animate(x, 100, {\n *     type: \"spring\",\n *     stiffness: 2000,\n *     onComplete: v => {}\n *   })\n *\n *   return controls.stop\n * })\n * ```\n *\n * @public\n */\nfunction animate(from, to, transition) {\n    if (transition === void 0) { transition = {}; }\n    var value = isMotionValue(from) ? from : motionValue(from);\n    startAnimation(\"\", value, to, transition);\n    return {\n        stop: function () { return value.stop(); },\n        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { domAnimation } from './features-animation.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign(__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\nexport { domMax };\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","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","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","hueToRgb","p","q","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","round","mixLinearColor","v","fromExpo","toExpo","max","colorTypes","hex","rgba","hsla","getColorType","find","type","test","notAnimatable","color","mixColor","fromColorType","toColorType","fromColor","parse","toColor","blended","mix","transform","getMixer","origin","target","mixComplex","mixArray","output","numValues","length","blendValue","map","fromThis","mixObject","analyse","parsed","complex","numNumbers","numRGB","numHSL","template","createTransformer","originStats","targetStats","pipe","mixNumber","interpolate","input","isClamp","ease","mixer","inputLength","Array","isArray","concat","reverse","mixers","customMixer","mixerFactory","numMixers","easingFunction","push","createMixers","interpolator","progress","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","defaultEasing","values","easing","splice","keyframes","offset","times","o","convertOffsetToTimes","_value","defaultOffset","createInterpolator","types","power","timeConstant","modifyTarget","amplitude","ideal","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","Set","has","detectAnimationFromOptions","call","animation","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","isEasingArray","isAnimatable","startsWith","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","x","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","default","getDefaultTransition","valueKey","transitionFactory","instantAnimationState","legacyRepeatWarning","getAnimation","transition","valueTransition","getValueTransition","get","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","getVelocity","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","LazyMotion","children","features","strict","setIsLoaded","useState","isLazyBundle","loadedRenderer","useRef","renderer","loadedFeatures","useEffect","then","Provider","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","point","changedTouches","pointFromMouse","extractEventInfo","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","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","isPoint","hasOwnProperty","isPoint3D","distance1D","distance","xDelta","yDelta","zDelta","PanSession","handlers","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","timestamp","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","prototype","updateHandlers","subtractPoint","lastDevicePoint","startDevicePoint","timeDelta","timestampedPoint","lastPoint","time","Infinity","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","calcLength","axis","isNear","maxDistance","calcAxisDelta","source","originPoint","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","AnimationType","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","callback","convertBoundingBoxToBox","top","left","right","bottom","isIdentityScale","hasScale","hasTransform","hasTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","translateAxis","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","transformBox","measureViewportBox","instance","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","isPresent","panSession","stopAnimation","getProps","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","getAxisMotionValue","measuredAxis","actual","animationState","setActive","Drag","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","syncRender","getTransformPagePoint","cancel","onDragEnd","_point","shouldDrag","axisValue","dragConstraints","prevConstraints","resolveRefConstraints","layoutBox","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","Promise","all","dragKey","toUpperCase","getValue","initial","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","transformTemplate","getInstance","style","updateScroll","updateLayout","addListeners","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","motionValue","props","_d","_e","_f","makeRenderlessComponent","hook","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useContext","MotionConfigContext","groupDragControls","dragControls","subscribe","usePresence","context","onExitComplete","register","id","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","isCSSVariable","cssVariableRegex","getVariableValue","depth","match","exec","parseCSSVariable","token","fallback","resolved","getComputedStyle","getPropertyValue","trim","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","replace","shadow","xScale","yScale","averageScale","i_1","cssVariable","MeasureLayoutWithContext","_super","apply","arguments","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","defaultScaleCorrectors","group","add","didUpdate","safeToRemove","setOptions","hasEverUpdated","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","postRender","getStack","members","componentDidUpdate","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","L","SwitchLayoutGroupContext","shallowCompare","prevLength","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Exit","reversePriorityOrder","numAnimationTypes","createTypeState","isActive","protectedKeys","needsAnimating","prevResolvedValues","animations","animateList","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","transitionEnd","animateChanges","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","_loop_1","typeState","prop","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","allKeys","markToAnimate","delete","blockInitialAnimation","size","fallbackAnimation_1","forEach","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","resolve","isAnimated","variantChildren","child","setAnimateFunction","makeAnimator","getState","createAnimationState","exit","custom","presenceContext","createHoverEvent","isNodeOrChild","parentElement","warned","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","thresholdNames","useIntersectionObserver","shouldObserve","rootMargin","margin","amount","once","threshold","rootInteresectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","observeIntersection","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","message","console","warn","requestAnimationFrame","BoundingBoxDimension","gestureAnimations","inView","whileInView","viewport","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","onPointerUp","onPointerCancel","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","names","treeType","build","makeTargetAnimatable","renderInstance","readValueFromInstance","removeValueFromRenderState","sortNodePosition","scrapeMotionValuesFromProps","presenceId","visualState","shouldReduceMotion","removeFromVariantTree","isMounted","latestValues","renderState","lifecycles","managers","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","_i","notify","createLifecycles","Map","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","notifyUpdate","bindToMotionValue","removeOnChange","onChange","latestValue","removeOnRenderRequest","onRenderRequest","scheduleRender","initialMotionValues","isControllingVariants","isVariantNode","isVisible","mount","newInstance","addVariantChild","setProps","unmount","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","getLatestValues","setVisibility","visibility","canMutate","addValue","hasValue","removeValue","defaultValue","forEachValue","readValue","setBaseTarget","newProps","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","getVariant","variants","startAtParent","context_1","numVariantProps","name_1","variantProps","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","filter","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","unitConversion","hasPositionalKey","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY_1","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","targetBbox","convertChangedValueTypes","scrollTo","checkAndConvertChangedValueTypes","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","vars","transformValues","Element","resolveCSSVariables","parseDomVariant","htmlVisualElement","svgVisualElement","getAttribute","_element","domAnimation","Component","enableHardwareAcceleration","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","identityProjection","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","isDirty","sort","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","ProjectionNode","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","animationProgress","sharedNodes","path","registerPotentialNode","notifyListeners","subscriptionManager","hasListeners","SVGElement","tagName","unblockTimeout_1","resizeUnblockUpdate_1","hasAnimatedSinceResize","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","mountNodeEarly","resetTransformStyle","notifyLayoutUpdate","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","measure","removeTransform","removeElementScroll","roundBox","alwaysMeasureLayout","prevLayout","layoutCorrected","notifyLayoutMeasure","layoutScroll","isScrollRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","attemptToResolveRelativeTarget","pendingAnimation","getLead","treePath","isSharedTransition","treeLength","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isAnimating","completeAnimation","applyTransformsToTarget","initialPromotionConfig","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","getProjectionStyles","styleProp","styles","pointerEvents","emptyStyles","valuesToRender","transformOrigin","_h","corrected","num","resetTree","layout_1","measuredLayout","animationType","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","searchNode","querySelector","roundAxis","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","documentNode","position","domMax","projectionNodeConstructor","getAnimatableNone","defaultValueType","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","dimensionValueTypes","vw","vh","findDimensionValueType","testValueType","animateVisualElement","notifyAnimationStart","variant","animateVariant","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getChildAnimations","forwardDelay","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","animateChildren","first","last","animationTypeState","valueTarget","shouldBlockAnimation","shouldBlock","isNumericalString","isZeroValueString","valueTypes","findValueType","setMotionValue","setTarget","setVariants","variantLabels","setValues","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","getOriginFromTransition","getOrigin","addUniqueItem","arr","item","removeItem","index","SubscriptionManager","subscriptions","numSubscriptions","getSize","secondsToMilliseconds","seconds","counter","incrementId","useId","useUnmountEffect","MotionValue","init","version","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","scheduleVelocityCheck","velocityCheck","subscription","clearListeners","attach","passiveEffect","getPrevious","clearAnimation","destroy","defaultTimestep","getCurrentTime","performance","now","Date","onNextFrame","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","process","frameData","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","getFrameData","reverseEasing","mirrorEasing","createBackIn","BOUNCE_FIRST_THRESHOLD","BOUNCE_SECOND_THRESHOLD","acos","backEasing","createAnticipate","ca","cb","cc","p2","isNum","combineFunctions","transformers","toFromDifference","velocityPerSecond","frameDuration","r","substr","parseInt","alpha$1","clampRgbUnit","rgbUnit","isColorString","testProp","splitColor","aName","bName","cName","maxDefaults","applyDefaultFilter","slice","number","unit","functionRegex","functions","join","colorToken","numberToken","numColors","colors","numbers","tokenised","convertNumbersToZero","transformer"],"sourceRoot":""}