{"version":3,"file":"react/js/vendor.framer-motion@current-4436cc51.8d4c747b184fa33bf51f.js","mappings":"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","sources":["webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/store.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack:///./node_modules/framer-motion/dist/es/render/VisualElement.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/scroll/observe.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/scroll/supports.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-element.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/resolve-variants.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/variant-props.mjs"],"sourcesContent":["import { invariant } from '../../../utils/errors.mjs';\nimport { isNumericalString } from '../../../utils/is-numerical-string.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst splitCSSVariableRegex = \n// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words\n/^var\\(--(?:([\\w-]+)|([\\w-]+), ?([a-zA-Z\\d ()%#.,-]+))\\)/u;\nfunction parseCSSVariable(current) {\n    const match = splitCSSVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token1, token2, fallback] = match;\n    return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        const trimmed = resolved.trim();\n        return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;\n    }\n    return isCSSVariableToken(fallback)\n        ? getVariableValue(fallback, element, depth + 1)\n        : fallback;\n}\n\nexport { getVariableValue, parseCSSVariable };\n","import { analyseComplexValue } from '../../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../../dom/value-types/animatable-none.mjs';\n\n/**\n * If we encounter keyframes like \"none\" or \"0\" and we also have keyframes like\n * \"#fff\" or \"200px 200px\" we want to find a keyframe to serve as a template for\n * the \"none\" keyframes. In this case \"#fff\" or \"200px 200px\" - then these get turned into\n * zero equivalents, i.e. \"#fff0\" or \"0px 0px\".\n */\nconst invalidTemplates = new Set([\"auto\", \"none\", \"0\"]);\nfunction makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {\n    let i = 0;\n    let animatableTemplate = undefined;\n    while (i < unresolvedKeyframes.length && !animatableTemplate) {\n        const keyframe = unresolvedKeyframes[i];\n        if (typeof keyframe === \"string\" &&\n            !invalidTemplates.has(keyframe) &&\n            analyseComplexValue(keyframe).values.length) {\n            animatableTemplate = unresolvedKeyframes[i];\n        }\n        i++;\n    }\n    if (animatableTemplate && name) {\n        for (const noneIndex of noneKeyframeIndexes) {\n            unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);\n        }\n    }\n}\n\nexport { makeNoneKeyframesAnimatable };\n","import { isNone } from '../../animation/utils/is-none.mjs';\nimport { getVariableValue } from './utils/css-variables-conversion.mjs';\nimport { isCSSVariableToken } from './utils/is-css-variable.mjs';\nimport { positionalKeys, isNumOrPxType, positionalValues } from './utils/unit-conversion.mjs';\nimport { findDimensionValueType } from './value-types/dimensions.mjs';\nimport { KeyframeResolver } from '../utils/KeyframesResolver.mjs';\nimport { makeNoneKeyframesAnimatable } from '../html/utils/make-none-animatable.mjs';\n\nclass DOMKeyframesResolver extends KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue) {\n        super(unresolvedKeyframes, onComplete, name, motionValue, motionValue === null || motionValue === void 0 ? void 0 : motionValue.owner, true);\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, element, name } = this;\n        if (!element.current)\n            return;\n        super.readKeyframes();\n        /**\n         * If any keyframe is a CSS variable, we need to find its value by sampling the element\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            let keyframe = unresolvedKeyframes[i];\n            if (typeof keyframe === \"string\") {\n                keyframe = keyframe.trim();\n                if (isCSSVariableToken(keyframe)) {\n                    const resolved = getVariableValue(keyframe, element.current);\n                    if (resolved !== undefined) {\n                        unresolvedKeyframes[i] = resolved;\n                    }\n                    if (i === unresolvedKeyframes.length - 1) {\n                        this.finalKeyframe = keyframe;\n                    }\n                }\n            }\n        }\n        /**\n         * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n         * have a far bigger performance impact.\n         */\n        this.resolveNoneKeyframes();\n        /**\n         * Check to see if unit type has changed. If so schedule jobs that will\n         * temporarily set styles to the destination keyframes.\n         * Skip if we have more than two keyframes or this isn't a positional value.\n         * TODO: We can throw if there are multiple keyframes and the value type changes.\n         */\n        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n            return;\n        }\n        const [origin, target] = unresolvedKeyframes;\n        const originType = findDimensionValueType(origin);\n        const targetType = findDimensionValueType(target);\n        /**\n         * Either we don't recognise these value types or we can animate between them.\n         */\n        if (originType === targetType)\n            return;\n        /**\n         * If both values are numbers or pixels, we can animate between them by\n         * converting them to numbers.\n         */\n        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n            for (let i = 0; i < unresolvedKeyframes.length; i++) {\n                const value = unresolvedKeyframes[i];\n                if (typeof value === \"string\") {\n                    unresolvedKeyframes[i] = parseFloat(value);\n                }\n            }\n        }\n        else {\n            /**\n             * Else, the only way to resolve this is by measuring the element.\n             */\n            this.needsMeasurement = true;\n        }\n    }\n    resolveNoneKeyframes() {\n        const { unresolvedKeyframes, name } = this;\n        const noneKeyframeIndexes = [];\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (isNone(unresolvedKeyframes[i])) {\n                noneKeyframeIndexes.push(i);\n            }\n        }\n        if (noneKeyframeIndexes.length) {\n            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);\n        }\n    }\n    measureInitialState() {\n        const { element, unresolvedKeyframes, name } = this;\n        if (!element.current)\n            return;\n        if (name === \"height\") {\n            this.suspendedScrollY = window.pageYOffset;\n        }\n        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        unresolvedKeyframes[0] = this.measuredOrigin;\n        // Set final key frame to measure after next render\n        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n        if (measureKeyframe !== undefined) {\n            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);\n        }\n    }\n    measureEndState() {\n        var _a;\n        const { element, name, unresolvedKeyframes } = this;\n        if (!element.current)\n            return;\n        const value = element.getValue(name);\n        value && value.jump(this.measuredOrigin, false);\n        const finalKeyframeIndex = unresolvedKeyframes.length - 1;\n        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];\n        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        if (finalKeyframe !== null && this.finalKeyframe === undefined) {\n            this.finalKeyframe = finalKeyframe;\n        }\n        // If we removed transform values, reapply them before the next render\n        if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {\n            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {\n                element\n                    .getValue(unsetTransformName)\n                    .set(unsetTransformValue);\n            });\n        }\n        this.resolveNoneKeyframes();\n    }\n}\n\nexport { DOMKeyframesResolver };\n","import { createMotionComponent } from '../../motion/index.mjs';\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig = {}) {\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    const componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: (_target, key) => {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\nexport { createMotionProxy };\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 */\nconst 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    \"switch\",\n    \"symbol\",\n    \"svg\",\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]/u.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\n","import { transformPropOrder } from './transform.mjs';\n\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\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(transform, { enableHardwareAcceleration = true, allowTransformNone = true, }, transformIsDefault, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        if (transform[key] !== undefined) {\n            const transformName = translateAlias[key] || key;\n            transformString += `${transformName}(${transform[key]}) `;\n        }\n    }\n    if (enableHardwareAcceleration && !transform.z) {\n        transformString += \"translateZ(0)\";\n    }\n    transformString = transformString.trim();\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\nexport { buildTransform };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nconst getValueAsType = (value, type) => {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","import { buildTransform } from './build-transform.mjs';\nimport { isCSSVariableName } from '../../dom/utils/is-css-variable.mjs';\nimport { transformProps } 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    const { style, vars, transform, transformOrigin } = state;\n    // Track whether we encounter any transform or transformOrigin values.\n    let hasTransform = false;\n    let hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    let 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 (const key in latestValues) {\n        const value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariableName(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        const valueType = numberValueTypes[key];\n        const valueAsType = getValueAsType(value, valueType);\n        if (transformProps.has(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\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 !== (valueType.default || 0))\n                transformIsNone = false;\n        }\n        else if (key.startsWith(\"origin\")) {\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n            transformOrigin[key] = valueAsType;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (!latestValues.transform) {\n        if (hasTransform || transformTemplate) {\n            style.transform = buildTransform(state.transform, options, transformIsNone, transformTemplate);\n        }\n        else if (style.transform) {\n            /**\n             * If we have previously created a transform but currently don't have any,\n             * reset transform style to none.\n             */\n            style.transform = \"none\";\n        }\n    }\n    /**\n     * Build a transformOrigin style. Uses the same defaults as the browser for\n     * undefined origins.\n     */\n    if (hasTransformOrigin) {\n        const { originX = \"50%\", originY = \"50%\", originZ = 0, } = transformOrigin;\n        style.transformOrigin = `${originX} ${originY} ${originZ}`;\n    }\n}\n\nexport { buildHTMLStyles };\n","const createHtmlRenderState = () => ({\n    style: {},\n    transform: {},\n    transformOrigin: {},\n    vars: {},\n});\n\nexport { createHtmlRenderState };\n","import { useMemo } from 'react';\nimport { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (const key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues({ transformTemplate }, visualState, isStatic) {\n    return useMemo(() => {\n        const state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        return Object.assign({}, state.vars, state.style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    const styleProp = props.style || {};\n    const style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    return style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    const htmlProps = {};\n    const style = useStyle(props, visualState, isStatic);\n    if (props.drag && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : `pan-${props.drag === \"x\" ? \"y\" : \"x\"}`;\n    }\n    if (props.tabIndex === undefined &&\n        (props.onTap || props.onTapStart || props.whileTap)) {\n        htmlProps.tabIndex = 0;\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps };\n","import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';\n\nlet shouldForward = (key) => !isValidMotionProp(key);\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = (key) => key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    const filteredProps = {};\n    for (const key in props) {\n        /**\n         * values is considered a valid prop by Emotion, so if it's present\n         * this will be rendered out to the DOM unless explicitly filtered.\n         *\n         * We check the type as it could be used with the `feColorMatrix`\n         * element, which we support.\n         */\n        if (key === \"values\" && typeof props.values === \"object\")\n            continue;\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] &&\n                key.startsWith(\"onDrag\"))) {\n            filteredProps[key] =\n                props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps, loadExternalIsValidProp };\n","import { px } from '../../../value/types/numbers/units.mjs';\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    const pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    const pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return `${pxOriginX} ${pxOriginY}`;\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from '../../../value/types/numbers/units.mjs';\n\nconst dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nconst 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 = 1, offset = 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    const keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    const pathLength = px.transform(length);\n    const pathSpacing = px.transform(spacing);\n    attrs[keys.array] = `${pathLength} ${pathSpacing}`;\n}\n\nexport { buildSVGPath };\n","import { 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, { attrX, attrY, attrScale, originX, originY, pathLength, pathSpacing = 1, pathOffset = 0, \n// This is object creation, which we try to avoid per-frame.\n...latest }, options, isSVGTag, transformTemplate) {\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    /**\n     * For svg tags we just want to make sure viewBox is animatable and treat all the styles\n     * as normal HTML tags.\n     */\n    if (isSVGTag) {\n        if (state.style.viewBox) {\n            state.attrs.viewBox = state.style.viewBox;\n        }\n        return;\n    }\n    state.attrs = state.style;\n    state.style = {};\n    const { attrs, style, dimensions } = state;\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    // Render attrX/attrY/attrScale as attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    if (attrScale !== undefined)\n        attrs.scale = attrScale;\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","import { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';\n\nconst createSvgRenderState = () => ({\n    ...createHtmlRenderState(),\n    attrs: {},\n});\n\nexport { createSvgRenderState };\n","const isSVGTag = (tag) => typeof tag === \"string\" && tag.toLowerCase() === \"svg\";\n\nexport { isSVGTag };\n","import { useMemo } from 'react';\nimport { copyRawValuesOnly } from '../html/use-props.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nfunction useSVGProps(props, visualState, _isStatic, Component) {\n    const visualProps = useMemo(() => {\n        const state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, isSVGTag(Component), props.transformTemplate);\n        return {\n            ...state.attrs,\n            style: { ...state.style },\n        };\n    }, [visualState]);\n    if (props.style) {\n        const rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = { ...rawStyles, ...visualProps.style };\n    }\n    return visualProps;\n}\n\nexport { useSVGProps };\n","import { Fragment, useMemo, createElement } from 'react';\nimport { useHTMLProps } from '../html/use-props.mjs';\nimport { filterProps } from './utils/filter-props.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\nimport { useSVGProps } from '../svg/use-props.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction createUseRender(forwardMotionProps = false) {\n    const useRender = (Component, props, ref, { latestValues }, isStatic) => {\n        const useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        const visualProps = useVisualProps(props, latestValues, isStatic, Component);\n        const filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        const elementProps = Component !== Fragment\n            ? { ...filteredProps, ...visualProps, ref }\n            : {};\n        /**\n         * If component has been handed a motion value as its child,\n         * memoise its initial value and render that. Subsequent updates\n         * will be handled by the onChange handler\n         */\n        const { children } = props;\n        const renderedChildren = useMemo(() => (isMotionValue(children) ? children.get() : children), [children]);\n        return createElement(Component, {\n            ...elementProps,\n            children: renderedChildren,\n        });\n    };\n    return useRender;\n}\n\nexport { createUseRender };\n","function renderHTML(element, { style, vars }, styleProp, projection) {\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (const key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nconst 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    \"startOffset\",\n    \"textLength\",\n    \"lengthAdjust\",\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 (const key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n    var _a;\n    const { style } = props;\n    const newValues = {};\n    for (const key in style) {\n        if (isMotionValue(style[key]) ||\n            (prevProps.style &&\n                isMotionValue(prevProps.style[key])) ||\n            isForcedMotionValue(key, props) ||\n            ((_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.liveStyle) !== undefined) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\nimport { transformPropOrder } from '../../html/utils/transform.mjs';\n\nfunction scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n    const newValues = scrapeMotionValuesFromProps$1(props, prevProps, visualElement);\n    for (const key in props) {\n        if (isMotionValue(props[key]) ||\n            isMotionValue(prevProps[key])) {\n            const targetKey = transformPropOrder.indexOf(key) !== -1\n                ? \"attr\" + key.charAt(0).toUpperCase() + key.substring(1)\n                : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: (props, instance, { renderState, latestValues }) => {\n            frame.read(() => {\n                try {\n                    renderState.dimensions =\n                        typeof instance.getBBox ===\n                            \"function\"\n                            ? instance.getBBox()\n                            : instance.getBoundingClientRect();\n                }\n                catch (e) {\n                    // Most likely trying to measure an unrendered element under Firefox\n                    renderState.dimensions = {\n                        x: 0,\n                        y: 0,\n                        width: 0,\n                        height: 0,\n                    };\n                }\n            });\n            frame.render(() => {\n                buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, isSVGTag(instance.tagName), props.transformTemplate);\n                renderSVG(instance, renderState);\n            });\n        },\n    }),\n};\n\nexport { svgMotionConfig };\n","import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nconst htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","const visualElementStore = new WeakMap();\n\nexport { visualElementStore };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","import { warning, invariant } from '../utils/errors.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isRefObject } from '../utils/is-ref-object.mjs';\nimport { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isWillChangeMotionValue } from '../value/use-will-change/is.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { transformProps } from './html/utils/transform.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { isVariantLabel } from './utils/is-variant-label.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { variantProps } from './utils/variant-props.mjs';\nimport { visualElementStore } from './store.mjs';\nimport { KeyframeResolver } from './utils/KeyframesResolver.mjs';\nimport { isNumericalString } from '../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../utils/is-zero-value-string.mjs';\nimport { findValueType } from './dom/value-types/find.mjs';\nimport { complex } from '../value/types/complex/index.mjs';\nimport { getAnimatableNone } from './dom/value-types/animatable-none.mjs';\nimport { frame, cancelFrame } from '../frameloop/frame.mjs';\n\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\nconst numVariantProps = variantProps.length;\nfunction getClosestProjectingNode(visualElement) {\n    if (!visualElement)\n        return undefined;\n    return visualElement.options.allowProjection !== false\n        ? visualElement.projection\n        : getClosestProjectingNode(visualElement.parent);\n}\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {\n        return {};\n    }\n    constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, visualState, }, options = {}) {\n        this.resolveKeyframes = (keyframes, \n        // We use an onComplete callback here rather than a Promise as a Promise\n        // resolution is a microtask and we want to retain the ability to force\n        // the resolution of keyframes synchronously.\n        onComplete, name, value) => {\n            return new this.KeyframeResolver(keyframes, onComplete, name, value, this);\n        };\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        this.values = new Map();\n        this.KeyframeResolver = KeyframeResolver;\n        /**\n         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.scheduleRender = () => frame.render(this.render, false, true);\n        const { latestValues, renderState } = visualState;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.presenceContext = presenceContext;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.blockInitialAnimation = Boolean(blockInitialAnimation);\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n                if (isWillChangeMotionValue(willChange)) {\n                    willChange.add(key);\n                }\n            }\n        }\n    }\n    mount(instance) {\n        this.current = instance;\n        visualElementStore.set(instance, this);\n        if (this.projection && !this.projection.instance) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = this.parent.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        var _a;\n        visualElementStore.delete(this.current);\n        this.projection && this.projection.unmount();\n        cancelFrame(this.notifyUpdate);\n        cancelFrame(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            (_a = this.features[key]) === null || _a === void 0 ? void 0 : _a.unmount();\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate && frame.preRender(this.notifyUpdate);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n            if (value.owner)\n                value.stop();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type) {\n            return 0;\n        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    loadFeatures({ children, ...renderedProps }, isStrict, preloadedFeatures, initialLayoutGroupConfig) {\n        let ProjectionNodeConstructor;\n        let MeasureLayout;\n        /**\n         * If we're in development mode, check to make sure we're not rendering a motion component\n         * as a child of LazyMotion, as this will break the file-size benefits of using it.\n         */\n        if (process.env.NODE_ENV !== \"production\" &&\n            preloadedFeatures &&\n            isStrict) {\n            const strictMessage = \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\";\n            renderedProps.ignoreStrict\n                ? warning(false, strictMessage)\n                : invariant(false, strictMessage);\n        }\n        for (let i = 0; i < numFeatures; i++) {\n            const name = featureNames[i];\n            const { isEnabled, Feature: FeatureConstructor, ProjectionNode, MeasureLayout: MeasureLayoutComponent, } = featureDefinitions[name];\n            if (ProjectionNode)\n                ProjectionNodeConstructor = ProjectionNode;\n            if (isEnabled(renderedProps)) {\n                if (!this.features[name] && FeatureConstructor) {\n                    this.features[name] = new FeatureConstructor(this);\n                }\n                if (MeasureLayoutComponent) {\n                    MeasureLayout = MeasureLayoutComponent;\n                }\n            }\n        }\n        if ((this.type === \"html\" || this.type === \"svg\") &&\n            !this.projection &&\n            ProjectionNodeConstructor) {\n            const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, } = renderedProps;\n            this.projection = new ProjectionNodeConstructor(this.latestValues, renderedProps[\"data-framer-portal-id\"]\n                ? undefined\n                : getClosestProjectingNode(this.parent));\n            this.projection.setOptions({\n                layoutId,\n                layout,\n                alwaysMeasureLayout: Boolean(drag) ||\n                    (dragConstraints && isRefObject(dragConstraints)),\n                visualElement: this,\n                scheduleRender: () => this.scheduleRender(),\n                /**\n                 * TODO: Update options in an effect. This could be tricky as it'll be too late\n                 * to update by the time layout animations run.\n                 * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n                 * ensuring it gets called if there's no potential layout animations.\n                 *\n                 */\n                animationType: typeof layout === \"string\" ? layout : \"both\",\n                initialPromotionConfig: initialLayoutGroupConfig,\n                layoutScroll,\n                layoutRoot,\n            });\n        }\n        return MeasureLayout;\n    }\n    updateFeatures() {\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature.isMounted) {\n                feature.update();\n            }\n            else {\n                feature.mount();\n                feature.isMounted = true;\n            }\n        }\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.options, this.props);\n    }\n    /**\n     * Measure the current viewport box with or without transforms.\n     * Only measures axis-aligned boxes, rotate and skew must be manually\n     * removed with a re-render to work.\n     */\n    measureViewportBox() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\n    }\n    /**\n     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listenerName = (\"on\" + key);\n            const listener = props[listenerName];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    getVariantContext(startAtParent = false) {\n        if (startAtParent) {\n            return this.parent ? this.parent.getVariantContext() : undefined;\n        }\n        if (!this.isControllingVariants) {\n            const context = this.parent\n                ? this.parent.getVariantContext() || {}\n                : {};\n            if (this.props.initial !== undefined) {\n                context.initial = this.props.initial;\n            }\n            return context;\n        }\n        const context = {};\n        for (let i = 0; i < numVariantProps; i++) {\n            const name = variantProps[i];\n            const prop = this.props[name];\n            if (isVariantLabel(prop) || prop === false) {\n                context[name] = prop;\n            }\n        }\n        return context;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        const existingValue = this.values.get(key);\n        if (value !== existingValue) {\n            if (existingValue)\n                this.removeValue(key);\n            this.bindToMotionValue(key, value);\n            this.values.set(key, value);\n            this.latestValues[key] = value.get();\n        }\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue === null ? undefined : defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key, target) {\n        var _a;\n        let value = this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);\n        if (value !== undefined && value !== null) {\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(target)) {\n                value = getAnimatableNone(key, target);\n            }\n            this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);\n        }\n        return isMotionValue(value) ? value.get() : value;\n    }\n    /**\n     * Set the base target to later animate back to. This is currently\n     * only hydrated on creation and when we first read a value.\n     */\n    setBaseTarget(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        let valueFromInitial;\n        if (typeof initial === \"string\" || typeof initial === \"object\") {\n            const variant = resolveVariantFromProps(this.props, initial, (_a = this.presenceContext) === null || _a === void 0 ? void 0 : _a.custom);\n            if (variant) {\n                valueFromInitial = variant[key];\n            }\n        }\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\n\nexport { VisualElement };\n","import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.2.10\", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.2.10 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                if (existingValue.liveStyle === true) {\n                    existingValue.jump(nextValue);\n                }\n                else if (!existingValue.hasAnimated) {\n                    existingValue.set(nextValue);\n                }\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { VisualElement } from '../VisualElement.mjs';\nimport { DOMKeyframesResolver } from './DOMKeyframesResolver.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    constructor() {\n        super(...arguments);\n        this.KeyframeResolver = DOMKeyframesResolver;\n    }\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props.style\n            ? props.style[key]\n            : undefined;\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n}\n\nexport { DOMVisualElement };\n","import { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariableName } from '../dom/utils/is-css-variable.mjs';\nimport { transformProps } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"html\";\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, options, props) {\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current)\n                    this.current.textContent = `${latest}`;\n            });\n        }\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderHTML(instance, renderState, styleProp, projection);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"svg\";\n        this.isSVGTag = false;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    measureInstanceViewportBox() {\n        return createBox();\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n    build(renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { Fragment } from 'react';\nimport { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';\nimport { SVGVisualElement } from '../svg/SVGVisualElement.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new SVGVisualElement(options, { enableHardwareAcceleration: false })\n        : new HTMLVisualElement(options, {\n            allowProjection: Component !== Fragment,\n            enableHardwareAcceleration: true,\n        });\n};\n\nexport { createDomVisualElement };\n","import { createMotionComponent } from '../../motion/index.mjs';\nimport { createMotionProxy } from './motion-proxy.mjs';\nimport { createDomMotionConfig } from './utils/create-config.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { animations } from '../../motion/features/animations.mjs';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\nimport { layout } from '../../motion/features/layout.mjs';\n\nconst preloadedFeatures = {\n    ...animations,\n    ...gestureAnimations,\n    ...drag,\n    ...layout,\n};\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nconst motion = /*@__PURE__*/ createMotionProxy((Component, config) => createDomMotionConfig(Component, config, preloadedFeatures, createDomVisualElement));\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, preloadedFeatures, createDomVisualElement));\n}\n\nexport { createDomMotionComponent, motion };\n","import { isSVGComponent } from './is-svg-component.mjs';\nimport { createUseRender } from '../use-render.mjs';\nimport { svgMotionConfig } from '../../svg/config-motion.mjs';\nimport { htmlMotionConfig } from '../../html/config-motion.mjs';\n\nfunction createDomMotionConfig(Component, { forwardMotionProps = false }, preloadedFeatures, createVisualElement) {\n    const baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return {\n        ...baseConfig,\n        preloadedFeatures,\n        useRender: createUseRender(forwardMotionProps),\n        createVisualElement,\n        Component,\n    };\n}\n\nexport { createDomMotionConfig };\n","import { frame, cancelFrame } from '../../../frameloop/frame.mjs';\n\nfunction observeTimeline(update, timeline) {\n    let prevProgress;\n    const onFrame = () => {\n        const { currentTime } = timeline;\n        const percentage = currentTime === null ? 0 : currentTime.value;\n        const progress = percentage / 100;\n        if (prevProgress !== progress) {\n            update(progress);\n        }\n        prevProgress = progress;\n    };\n    frame.update(onFrame, true);\n    return () => cancelFrame(onFrame);\n}\n\nexport { observeTimeline };\n","import { memo } from '../../../utils/memo.mjs';\n\nconst supportsScrollTimeline = memo(() => window.ScrollTimeline !== undefined);\n\nexport { supportsScrollTimeline };\n","/**\n * Convert camelCase to dash-case properties.\n */\nconst camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, \"$1-$2\").toLowerCase();\n\nexport { camelToDash };\n","const checkStringStartsWith = (token) => (key) => typeof key === \"string\" && key.startsWith(token);\nconst isCSSVariableName = checkStringStartsWith(\"--\");\nconst startsAsVariableToken = checkStringStartsWith(\"var(--\");\nconst isCSSVariableToken = (value) => {\n    const startsWithToken = startsAsVariableToken(value);\n    if (!startsWithToken)\n        return false;\n    // Ensure any comments are stripped from the value as this can harm performance of the regex.\n    return singleCssVariableRegex.test(value.split(\"/*\")[0].trim());\n};\nconst singleCssVariableRegex = /var\\(--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)$/iu;\n\nexport { isCSSVariableName, isCSSVariableToken };\n","function isSVGElement(element) {\n    return element instanceof SVGElement && element.tagName !== \"svg\";\n}\n\nexport { isSVGElement };\n","import { transformPropOrder } from '../../html/utils/transform.mjs';\nimport { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n    \"translateX\",\n    \"translateY\",\n]);\nconst isNumOrPxType = (v) => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/u);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/u);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\n// Alias translate longform names\npositionalValues.translateX = positionalValues.x;\npositionalValues.translateY = positionalValues.y;\n\nexport { isNumOrPxType, positionalKeys, positionalValues, removeNonTranslationalTransform };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\n}\n\nexport { getAnimatableNone };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","import { number } from '../../../value/types/numbers/index.mjs';\n\nconst int = {\n    ...number,\n    transform: Math.round,\n};\n\nexport { int };\n","import { scale, alpha } from '../../../value/types/numbers/index.mjs';\nimport { px, degrees, progressPercentage } from '../../../value/types/numbers/units.mjs';\nimport { int } from './type-int.mjs';\n\nconst 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,\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    backgroundPositionX: px,\n    backgroundPositionY: px,\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 */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","/**\n * Generate a list of every possible transform key.\n */\nconst transformPropOrder = [\n    \"transformPerspective\",\n    \"x\",\n    \"y\",\n    \"z\",\n    \"translateX\",\n    \"translateY\",\n    \"translateZ\",\n    \"scale\",\n    \"scaleX\",\n    \"scaleY\",\n    \"rotate\",\n    \"rotateX\",\n    \"rotateY\",\n    \"rotateZ\",\n    \"skew\",\n    \"skewX\",\n    \"skewY\",\n];\n/**\n * A quick lookup for transform props.\n */\nconst transformProps = new Set(transformPropOrder);\n\nexport { transformPropOrder, transformProps };\n","import { removeNonTranslationalTransform } from '../dom/utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    var _a;\n                    (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete());\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    readAllKeyframes();\n    measureAllKeyframes();\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        /**\n         * Track whether this resolver has completed. Once complete, it never\n         * needs to attempt keyframe resolution again.\n         */\n        this.isComplete = false;\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        /**\n         * Track whether this resolver is currently scheduled to resolve\n         * to allow it to be cancelled and resumed externally.\n         */\n        this.isScheduled = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.isScheduled = true;\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        /**\n         * If a keyframe is null, we hydrate it either by reading it from\n         * the instance, or propagating from previous keyframes.\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null) {\n                /**\n                 * If the first keyframe is null, we need to find its value by sampling the element\n                 */\n                if (i === 0) {\n                    const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();\n                    const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n                    if (currentValue !== undefined) {\n                        unresolvedKeyframes[0] = currentValue;\n                    }\n                    else if (element && name) {\n                        const valueAsRead = element.readValue(name, finalKeyframe);\n                        if (valueAsRead !== undefined && valueAsRead !== null) {\n                            unresolvedKeyframes[0] = valueAsRead;\n                        }\n                    }\n                    if (unresolvedKeyframes[0] === undefined) {\n                        unresolvedKeyframes[0] = finalKeyframe;\n                    }\n                    if (motionValue && currentValue === undefined) {\n                        motionValue.set(unresolvedKeyframes[0]);\n                    }\n                }\n                else {\n                    unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];\n                }\n            }\n        }\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete() {\n        this.isComplete = true;\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (!this.isComplete) {\n            this.isScheduled = false;\n            toResolve.delete(this);\n        }\n    }\n    resume() {\n        if (!this.isComplete)\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (type) => (acc, definition) => {\n        var _a;\n        const resolved = resolveVariant(visualElement, definition, type === \"exit\"\n            ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n            : undefined);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(changedActiveType) {\n        const props = visualElement.getProps();\n        const context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined\n                ? props[type]\n                : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] &&\n                prop !== props[type] &&\n                propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            let handledRemovedValues = false;\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = false;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                let valueHasChanged = false;\n                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    if (next !== undefined && next !== null) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             */\n            if (shouldAnimateType && (!isInherited || handledRemovedValues)) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = true;\n                // @ts-expect-error - @mattgperry to figure if we should do something here\n                fallbackAnimation[key] = fallbackTarget !== null && fallbackTarget !== void 0 ? fallbackTarget : null;\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n","const compareByDepth = (a, b) => a.depth - b.depth;\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\nexport { FlatTree };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nfunction isControllingVariants(props) {\n    return (isAnimationControls(props.animate) ||\n        variantProps.some((name) => isVariantLabel(props[name])));\n}\nfunction isVariantNode(props) {\n    return Boolean(isControllingVariants(props) || props.variants);\n}\n\nexport { isControllingVariants, isVariantNode };\n","/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || Array.isArray(v);\n}\n\nexport { isVariantLabel };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);\n}\n\nexport { resolveVariant };\n","function getValueState(visualElement) {\n    const state = [{}, {}];\n    visualElement === null || visualElement === void 0 ? void 0 : visualElement.values.forEach((value, key) => {\n        state[0][key] = value.get();\n        state[1][key] = value.getVelocity();\n    });\n    return state;\n}\nfunction resolveVariantFromProps(props, definition, custom, visualElement) {\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        const [current, velocity] = getValueState(visualElement);\n        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);\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 = props.variants && props.variants[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        const [current, velocity] = getValueState(visualElement);\n        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);\n    }\n    return definition;\n}\n\nexport { resolveVariantFromProps };\n","import { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\n\nexport { setTarget };\n","const variantPriorityOrder = [\n    \"animate\",\n    \"whileInView\",\n    \"whileFocus\",\n    \"whileHover\",\n    \"whileTap\",\n    \"whileDrag\",\n    \"exit\",\n];\nconst variantProps = [\"initial\", ...variantPriorityOrder];\n\nexport { variantPriorityOrder, variantProps };\n"],"names":["splitCSSVariableRegex","getVariableValue","current","element","depth","token","fallback","match","exec","token1","token2","parseCSSVariable","resolved","window","getComputedStyle","getPropertyValue","trimmed","trim","i","parseFloat","invalidTemplates","Set","DOMKeyframesResolver","constructor","unresolvedKeyframes","onComplete","name","motionValue","super","owner","readKeyframes","this","length","keyframe","undefined","finalKeyframe","resolveNoneKeyframes","has","origin","target","originType","targetType","value","needsMeasurement","noneKeyframeIndexes","push","animatableTemplate","values","noneIndex","makeNoneKeyframesAnimatable","measureInitialState","suspendedScrollY","pageYOffset","measuredOrigin","measureViewportBox","measureKeyframe","getValue","jump","measureEndState","_a","finalKeyframeIndex","removedTransforms","forEach","unsetTransformName","unsetTransformValue","set","createMotionProxy","createConfig","custom","Component","customMotionComponentConfig","Proxy","componentCache","Map","get","_target","key","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","translateAlias","x","y","z","transformPerspective","numTransforms","getValueAsType","type","transform","buildHTMLStyles","state","latestValues","options","transformTemplate","style","vars","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","number","valueAsType","default","startsWith","enableHardwareAcceleration","allowTransformNone","transformIsDefault","transformString","buildTransform","originX","originY","originZ","createHtmlRenderState","copyRawValuesOnly","source","props","useStyle","visualState","isStatic","Object","assign","useMemo","useInitialMotionValues","useHTMLProps","htmlProps","drag","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","tabIndex","onTap","onTapStart","whileTap","shouldForward","isValidProp","require","calcOrigin","offset","size","px","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","attrScale","pathLength","pathSpacing","pathOffset","latest","isSVGTag","viewBox","attrs","dimensions","width","height","calcSVGTransformOrigin","scale","spacing","useDashCase","keys","buildSVGPath","createSvgRenderState","tag","toLowerCase","useSVGProps","_isStatic","visualProps","rawStyles","createUseRender","forwardMotionProps","ref","filteredProps","isDom","filterProps","elementProps","Fragment","children","renderedChildren","createElement","renderHTML","styleProp","projection","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps","prevProps","visualElement","newValues","liveStyle","charAt","toUpperCase","substring","svgMotionConfig","useVisualState","createRenderState","onMount","instance","read","getBBox","getBoundingClientRect","e","render","tagName","htmlMotionConfig","visualElementStore","WeakMap","valueTypes","color","complex","featureNames","numFeatures","propEventHandlers","numVariantProps","getClosestProjectingNode","allowProjection","parent","VisualElement","_props","_prevProps","_visualElement","presenceContext","reducedMotionConfig","blockInitialAnimation","resolveKeyframes","keyframes","KeyframeResolver","isVariantNode","isControllingVariants","shouldReduceMotion","features","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","notify","triggerBuild","renderInstance","scheduleRender","baseTarget","initialValues","initial","Boolean","variantChildren","manuallyAnimateOnMount","willChange","initialMotionValues","is","add","mount","removeFromVariantTree","addVariantChild","bindToMotionValue","update","unmount","delete","remove","clear","valueIsTransform","removeOnChange","on","latestValue","onUpdate","preRender","isTransformDirty","removeOnRenderRequest","stop","sortNodePosition","other","sortInstanceNodePosition","loadFeatures","renderedProps","isStrict","preloadedFeatures","initialLayoutGroupConfig","ProjectionNodeConstructor","MeasureLayout","isEnabled","Feature","FeatureConstructor","ProjectionNode","MeasureLayoutComponent","layoutId","layout","dragConstraints","layoutScroll","layoutRoot","setOptions","alwaysMeasureLayout","animationType","initialPromotionConfig","updateFeatures","feature","isMounted","build","measureInstanceViewportBox","getStaticValue","setStaticValue","prevPresenceContext","listener","next","prev","nextValue","prevValue","addValue","hasValue","existingValue","hasAnimated","removeValue","updateMotionValuesFromProps","handleChildMotionValue","getProps","getVariant","variants","getDefaultTransition","transition","getTransformPagePoint","transformPagePoint","getClosestVariantNode","getVariantContext","startAtParent","context","prop","child","closestVariantNode","unsubscribe","removeValueFromRenderState","defaultValue","readValue","getBaseTargetFromProps","readValueFromInstance","v","find","setBaseTarget","getBaseTarget","valueFromInitial","variant","eventName","callback","args","DOMVisualElement","arguments","a","b","compareDocumentPosition","HTMLVisualElement","defaultType","computedStyle","measure","m","childSubscription","textContent","SVGVisualElement","getAttribute","animations","config","createVisualElement","useRender","observeTimeline","timeline","prevProgress","onFrame","currentTime","progress","supportsScrollTimeline","ScrollTimeline","camelToDash","str","replace","checkStringStartsWith","isCSSVariableName","startsAsVariableToken","isCSSVariableToken","singleCssVariableRegex","split","isSVGElement","SVGElement","positionalKeys","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","filter","removeNonTranslationalTransform","positionalValues","paddingLeft","paddingRight","max","min","paddingTop","paddingBottom","top","left","bottom","right","translateX","translateY","getAnimatableNone","defaultValueType","defaultValueTypes","backgroundColor","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","dimensionValueTypes","vw","vh","parse","findDimensionValueType","Math","round","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","padding","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateZ","perspective","opacity","zIndex","backgroundPositionX","backgroundPositionY","fillOpacity","strokeOpacity","numOctaves","testValueType","transformPropOrder","transformProps","toResolve","isScheduled","anyNeedsMeasurement","measureAllKeyframes","resolversToMeasure","Array","from","resolver","elementsToMeasure","map","transformsToRestore","restore","scrollTo","complete","readAllKeyframes","flushKeyframeResolvers","isAsync","isComplete","scheduleResolve","currentValue","valueAsRead","setFinalKeyframe","renderEndStyles","cancel","resume","reversePriorityOrder","reverse","numAnimationTypes","createAnimationState","animate","Promise","all","animation","animateList","createTypeState","whileInView","whileHover","whileDrag","whileFocus","exit","isInitialRender","buildResolvedTypeValues","acc","definition","transitionEnd","animateChanges","changedActiveType","removedKeys","encounteredKeys","removedVariantIndex","Infinity","typeState","propIsVariant","activeDelta","isActive","isInherited","protectedKeys","prevProp","shouldAnimateType","checkVariantsDidChange","handledRemovedValues","definitionList","isArray","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","needsAnimating","hasOwnProperty","valueHasChanged","fallbackAnimation","fallbackTarget","shouldAnimate","resolve","setActive","animationState","setAnimateFunction","makeAnimator","getState","compareByDepth","FlatTree","isDirty","sort","some","isVariantLabel","resolveVariant","getValueState","getVelocity","resolveVariantFromProps","velocity","setMotionValue","setTarget","variantPriorityOrder","variantProps"],"sourceRoot":""}