{"version":3,"file":"3733-32d051b1bac625fac7df.js","mappings":"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","sources":["webpack://brc/./node_modules/hey-listen/dist/hey-listen.es.js","webpack://brc/./node_modules/react-spinners/esm/helpers/unitConverter.js","webpack://brc/./node_modules/react-spinners/esm/helpers/animation.js","webpack://brc/./node_modules/react-spinners/esm/PuffLoader.js","webpack://brc/./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack://brc/./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/utils/find-spring.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/generators/spring.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/hsla-to-rgba.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/mix-color.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/mix-complex.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/interpolate.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/generators/keyframes.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/generators/decay.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/utils/elapsed.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/index.mjs","webpack://brc/./node_modules/popmotion/dist/es/easing/cubic-bezier.mjs","webpack://brc/./node_modules/framer-motion/dist/es/animation/utils/easing.mjs","webpack://brc/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://brc/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://brc/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://brc/./node_modules/popmotion/dist/es/animations/inertia.mjs","webpack://brc/./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack://brc/./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack://brc/./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/animation.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/variants.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/process.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://brc/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://brc/./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack://brc/./node_modules/framesync/dist/es/on-next-frame.mjs","webpack://brc/./node_modules/framesync/dist/es/index.mjs","webpack://brc/./node_modules/framesync/dist/es/create-render-step.mjs","webpack://brc/./node_modules/popmotion/dist/es/easing/utils.mjs","webpack://brc/./node_modules/popmotion/dist/es/easing/index.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/clamp.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/inc.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/mix.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/pipe.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/progress.mjs","webpack://brc/./node_modules/popmotion/dist/es/utils/velocity-per-second.mjs","webpack://brc/./node_modules/style-value-types/dist/es/color/hex.mjs","webpack://brc/./node_modules/style-value-types/dist/es/color/hsla.mjs","webpack://brc/./node_modules/style-value-types/dist/es/color/index.mjs","webpack://brc/./node_modules/style-value-types/dist/es/color/rgba.mjs","webpack://brc/./node_modules/style-value-types/dist/es/color/utils.mjs","webpack://brc/./node_modules/style-value-types/dist/es/complex/filter.mjs","webpack://brc/./node_modules/style-value-types/dist/es/complex/index.mjs","webpack://brc/./node_modules/style-value-types/dist/es/numbers/index.mjs","webpack://brc/./node_modules/style-value-types/dist/es/numbers/units.mjs","webpack://brc/./node_modules/style-value-types/dist/es/utils.mjs"],"sourcesContent":["var warning = function () { };\r\nvar invariant = function () { };\r\nif (process.env.NODE_ENV !== 'production') {\r\n    warning = function (check, message) {\r\n        if (!check && typeof console !== 'undefined') {\r\n            console.warn(message);\r\n        }\r\n    };\r\n    invariant = function (check, message) {\r\n        if (!check) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n}\n\nexport { invariant, warning };\n","var cssUnit = {\n    cm: true,\n    mm: true,\n    in: true,\n    px: true,\n    pt: true,\n    pc: true,\n    em: true,\n    ex: true,\n    ch: true,\n    rem: true,\n    vw: true,\n    vh: true,\n    vmin: true,\n    vmax: true,\n    \"%\": true,\n};\n/**\n * If size is a number, append px to the value as default unit.\n * If size is a string, validate against list of valid units.\n * If unit is valid, return size as is.\n * If unit is invalid, console warn issue, replace with px as the unit.\n *\n * @param {(number | string)} size\n * @return {LengthObject} LengthObject\n */\nexport function parseLengthAndUnit(size) {\n    if (typeof size === \"number\") {\n        return {\n            value: size,\n            unit: \"px\",\n        };\n    }\n    var value;\n    var valueString = (size.match(/^[0-9.]*/) || \"\").toString();\n    if (valueString.includes(\".\")) {\n        value = parseFloat(valueString);\n    }\n    else {\n        value = parseInt(valueString, 10);\n    }\n    var unit = (size.match(/[^0-9]*$/) || \"\").toString();\n    if (cssUnit[unit]) {\n        return {\n            value: value,\n            unit: unit,\n        };\n    }\n    console.warn(\"React Spinners: \".concat(size, \" is not a valid css value. Defaulting to \").concat(value, \"px.\"));\n    return {\n        value: value,\n        unit: \"px\",\n    };\n}\n/**\n * Take value as an input and return valid css value\n *\n * @param {(number | string)} value\n * @return {string} valid css value\n */\nexport function cssValue(value) {\n    var lengthWithunit = parseLengthAndUnit(value);\n    return \"\".concat(lengthWithunit.value).concat(lengthWithunit.unit);\n}\n","export var createAnimation = function (loaderName, frames, suffix) {\n    var animationName = \"react-spinners-\".concat(loaderName, \"-\").concat(suffix);\n    if (typeof window == \"undefined\" || !window.document) {\n        return animationName;\n    }\n    var styleEl = document.createElement(\"style\");\n    document.head.appendChild(styleEl);\n    var styleSheet = styleEl.sheet;\n    var keyFrames = \"\\n    @keyframes \".concat(animationName, \" {\\n      \").concat(frames, \"\\n    }\\n  \");\n    if (styleSheet) {\n        styleSheet.insertRule(keyFrames, 0);\n    }\n    return animationName;\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport * as React from \"react\";\nimport { cssValue } from \"./helpers/unitConverter\";\nimport { createAnimation } from \"./helpers/animation\";\nvar puff = [\n    createAnimation(\"PuffLoader\", \"0% {transform: scale(0)} 100% {transform: scale(1.0)}\", \"puff-1\"),\n    createAnimation(\"PuffLoader\", \"0% {opacity: 1} 100% {opacity: 0}\", \"puff-2\"),\n];\nfunction PuffLoader(_a) {\n    var _b = _a.loading, loading = _b === void 0 ? true : _b, _c = _a.color, color = _c === void 0 ? \"#000000\" : _c, _d = _a.speedMultiplier, speedMultiplier = _d === void 0 ? 1 : _d, _e = _a.cssOverride, cssOverride = _e === void 0 ? {} : _e, _f = _a.size, size = _f === void 0 ? 60 : _f, additionalprops = __rest(_a, [\"loading\", \"color\", \"speedMultiplier\", \"cssOverride\", \"size\"]);\n    var wrapper = __assign({ display: \"inherit\", position: \"relative\", width: cssValue(size), height: cssValue(size) }, cssOverride);\n    var style = function (i) {\n        return {\n            position: \"absolute\",\n            height: cssValue(size),\n            width: cssValue(size),\n            border: \"thick solid \".concat(color),\n            borderRadius: \"50%\",\n            opacity: \"1\",\n            top: \"0\",\n            left: \"0\",\n            animationFillMode: \"both\",\n            animation: \"\".concat(puff[0], \", \").concat(puff[1]),\n            animationDuration: \"\".concat(2 / speedMultiplier, \"s\"),\n            animationIterationCount: \"infinite\",\n            animationTimingFunction: \"cubic-bezier(0.165, 0.84, 0.44, 1), cubic-bezier(0.3, 0.61, 0.355, 1)\",\n            animationDelay: i === 1 ? \"-1s\" : \"0s\",\n        };\n    };\n    if (!loading) {\n        return null;\n    }\n    return (React.createElement(\"span\", __assign({ style: wrapper }, additionalprops),\n        React.createElement(\"span\", { style: style(1) }),\n        React.createElement(\"span\", { style: style(2) })));\n}\nexport default PuffLoader;\n","function isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nexport { isAnimationControls };\n","var isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","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 { createContext } from 'react';\n\nvar LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n","import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","var scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nexport { camelToDash };\n","/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable(key) {\n    return key.startsWith(\"--\");\n}\n\nexport { isCSSVariable };\n","/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\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","import { __assign } from 'tslib';\nimport { number } from 'style-value-types';\n\nvar int = __assign(__assign({}, number), { transform: Math.round });\n\nexport { int };\n","import { px, degrees, scale, alpha, progressPercentage } from 'style-value-types';\nimport { int } from './type-int.mjs';\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\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 { sortTransformProps } from './transform.mjs';\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\nexport { buildTransform, buildTransformOrigin };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","import { buildTransform, buildTransformOrigin } from './build-transform.mjs';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.mjs';\nimport { isTransformProp, isTransformOriginProp } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nexport { buildHTMLStyles };\n","function renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n","import { px } from 'style-value-types';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    var pathLength = px.transform(length);\n    var pathSpacing = px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = __rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nexport { camelCaseAttributes };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\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","/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nexport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };\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","var isBrowser = typeof document !== \"undefined\";\n\nexport { isBrowser };\n","/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nexport { env };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\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 { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\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","var isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nexport { isMotionValue };\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","import { clamp } from '../utils.mjs';\n\nconst number = {\n    test: (v) => typeof v === 'number',\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = Object.assign(Object.assign({}, number), { transform: clamp(0, 1) });\nconst scale = Object.assign(Object.assign({}, number), { default: 1 });\n\nexport { alpha, number, scale };\n","import { isString } from '../utils.mjs';\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(' ').length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType('deg');\nconst percent = createUnitType('%');\nconst px = createUnitType('px');\nconst vh = createUnitType('vh');\nconst vw = createUnitType('vw');\nconst progressPercentage = Object.assign(Object.assign({}, percent), { parse: (v) => percent.parse(v) / 100, transform: (v) => percent.transform(v * 100) });\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","const clamp = (min, max) => (v) => Math.max(Math.min(v, max), min);\nconst sanitize = (v) => (v % 1 ? Number(v.toFixed(5)) : v);\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nexport { clamp, colorRegex, floatRegex, isString, sanitize, singleColorRegex };\n"],"names":["warning","invariant","cssUnit","cm","mm","in","px","pt","pc","em","ex","ch","rem","vw","vh","vmin","vmax","cssValue","value","lengthWithunit","size","unit","valueString","match","toString","includes","parseFloat","parseInt","console","warn","concat","parseLengthAndUnit","createAnimation","loaderName","frames","suffix","animationName","window","document","styleEl","createElement","head","appendChild","styleSheet","sheet","keyFrames","insertRule","__assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","puff","_a","_b","loading","_c","color","_d","speedMultiplier","_e","cssOverride","_f","additionalprops","e","indexOf","getOwnPropertySymbols","propertyIsEnumerable","__rest","wrapper","display","position","width","height","style","border","borderRadius","opacity","top","left","animationFillMode","animation","animationDuration","animationIterationCount","animationTimingFunction","animationDelay","isAnimationControls","v","start","isKeyframesTarget","Array","isArray","safeMin","minDuration","maxDuration","minDamping","maxDamping","rootIterations","calcAngularFreq","undampedFreq","dampingRatio","Math","sqrt","durationKeys","physicsKeys","isSpringType","options","keys","some","key","undefined","spring","from","to","restSpeed","restDelta","state","done","stiffness","damping","mass","velocity","duration","isResolvedFromDuration","springOptions","derived","bounce","envelope","derivative","clamp","exponentialDecay","delta","a","b","c","exp","d","pow","f","g","initialGuess","result","approximateRoot","isNaN","findSpring","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","min","abs","angularFreq","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","next","current","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","hueToRgb","q","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","round","mixLinearColor","fromExpo","toExpo","max","colorTypes","hex","rgba","hsla","getColorType","find","type","test","notAnimatable","mixColor","fromColorType","toColorType","fromColor","parse","toColor","blended","mix","transform","getMixer","origin","target","mixComplex","mixArray","output","numValues","blendValue","map","fromThis","mixObject","analyse","parsed","complex","numNumbers","numRGB","numHSL","template","createTransformer","originStats","targetStats","pipe","mixNumber","interpolate","input","isClamp","ease","mixer","inputLength","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","stop","animate","autoplay","driver","repeat","repeatMax","repeatType","repeatDelay","onPlay","onStop","onComplete","onRepeat","onUpdate","driverControls","latest","interpolateFromNumber","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","config","Set","has","detectAnimationFromOptions","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","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","potentialUnitType","delayTimer","controls","getDelayFromTransition","setTimeout","clearTimeout","LazyContext","createContext","strict","PresenceContext","createDefinition","propNames","isEnabled","props","name","featureDefinitions","measureLayout","exit","drag","focus","hover","tap","pan","inView","loadFeatures","features","projectionNodeConstructor","Component","isForcedMotionValue","layout","layoutId","scaleCorrectors","addScaleCorrector","correctors","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","isCSSVariable","lowercaseSVGElements","isSVGComponent","getAnimatableNone","defaultValueType","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","filter","WebkitFilter","getDefaultValueType","dimensionValueTypes","findDimensionValueType","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","right","bottom","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","transformPerspective","originX","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","testValueType","translateAlias","getValueAsType","buildHTMLStyles","latestValues","transformTemplate","vars","transformKeys","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","number","valueAsType","transformIsDefault","enableHardwareAcceleration","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","trim","buildTransform","buildTransformOrigin","renderHTML","element","styleProp","projection","getProjectionStyles","setProperty","scrapeMotionValuesFromProps","newValues","transformAxes","transformProps","sortTransformProps","forEach","operationKey","axesKey","transformPropSet","isTransformProp","transformOriginProps","isTransformOriginProp","calcOrigin","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","attrs","dimensions","pxOriginX","pxOriginY","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","toUpperCase","animateVisualElement","visualElement","notifyAnimationStart","animations","variant","animateVariant","Promise","all","resolvedDefinition","custom","animateTarget","then","notifyAnimationComplete","resolved","transitionOverride","resolve","getChildAnimations","variantChildren","forwardDelay","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","child","animateChildren","first","last","makeTargetAnimatable","transitionEnd","animationTypeState","animationState","getState","getValue","valueTarget","shouldBlockAnimation","shouldReduceMotion","stopAnimation","forEachValue","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","isNumericalString","isZeroValueString","valueTypes","findValueType","setMotionValue","hasValue","addValue","setTarget","setVariants","variantLabels","getVariant","setValues","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","getOrigin","isVariantLabels","isVariantLabel","resolveVariantFromProps","currentValues","variants","resolveVariant","getProps","getCurrent","checkIfControllingVariants","initial","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","Boolean","addUniqueItem","arr","item","removeItem","index","isBrowser","env","process","isCustomValue","toValue","resolveFinalValueInKeyframes","SubscriptionManager","subscriptions","add","handler","_this","notify","numSubscriptions","getSize","clear","secondsToMilliseconds","seconds","useConstant","init","ref","useRef","MotionValue","version","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","render","timestamp","postRender","scheduleVelocityCheck","velocityCheck","hasAnimated","onChange","subscription","clearListeners","onRenderRequest","attach","passiveEffect","getPrevious","clearAnimation","isAnimating","destroy","motionValue","isMotionValue","defaultTimestep","getCurrentTime","performance","now","Date","onNextFrame","callback","requestAnimationFrame","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","reduce","acc","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","cancel","delete","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","alpha$1","clampRgbUnit","rgbUnit","isColorString","testProp","splitColor","aName","bName","cName","maxDefaults","applyDefaultFilter","slice","split","defaultValue","functionRegex","functions","join","colorToken","numberToken","numColors","colors","numbers","tokenised","convertNumbersToZero","transformer","createUnitType","endsWith","degrees","percent","progressPercentage","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString"],"sourceRoot":""}