{"version":3,"file":"js/4078-d7689eadce01bdb0d645.chunk.js","mappings":"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","sources":["webpack://printivity/./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/use-features.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/variants.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/node/state.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/node/id.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/VisualElementHandler.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/index.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/use-projection.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/utils.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/numbers/units.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/numbers/index.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/types.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/events/use-dom-event.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/events/utils.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/pipe.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/warn-once.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/use-id.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/clamp.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/utils/find-spring.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/generators/spring.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/progress.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/mix.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/color/utils.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/color/rgba.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/color/hex.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/color/hsla.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/hsla-to-rgba.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/mix-color.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/color/index.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/complex/index.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/inc.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/mix-complex.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/interpolate.mjs","webpack://printivity/./node_modules/popmotion/dist/es/easing/utils.mjs","webpack://printivity/./node_modules/popmotion/dist/es/easing/index.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/generators/keyframes.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/generators/decay.mjs","webpack://printivity/./node_modules/framesync/dist/es/on-next-frame.mjs","webpack://printivity/./node_modules/framesync/dist/es/index.mjs","webpack://printivity/./node_modules/framesync/dist/es/create-render-step.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/utils/elapsed.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/index.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/velocity-per-second.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://printivity/./node_modules/popmotion/dist/es/easing/cubic-bezier.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/utils/easing.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://printivity/./node_modules/style-value-types/dist/es/complex/filter.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://printivity/./node_modules/popmotion/dist/es/animations/inertia.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/animation.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://printivity/./node_modules/popmotion/dist/es/utils/distance.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/PanSession.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/index.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/html/visual-element.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/motion.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://printivity/./node_modules/framer-motion/dist/es/utils/use-reduced-motion.mjs"],"sourcesContent":["import { createContext } from 'react';\n\n/**\n * @public\n */\nvar MotionConfigContext = createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n","import { createContext } from 'react';\n\nvar LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { env } from '../../utils/process.mjs';\nimport { featureDefinitions } from './definitions.mjs';\nimport { invariant } from 'hey-listen';\nimport { LazyContext } from '../../context/LazyContext.mjs';\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = useContext(LazyContext);\n    if (!visualElement)\n        return null;\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 (env !== \"production\" && preloadedFeatures && lazyContext.strict) {\n        invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React.createElement(Component, __assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\nexport { useFeatures };\n","import { createContext, useContext } from 'react';\n\nvar MotionContext = createContext({});\nfunction useVisualElementContext() {\n    return useContext(MotionContext).visualElement;\n}\n\nexport { MotionContext, useVisualElementContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nvar useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n","import { useContext, useRef, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useVisualElementContext } from '../../context/MotionContext/index.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { useReducedMotionConfig } from '../../utils/use-reduced-motion.mjs';\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\n    var visualElementRef = useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nexport { useVisualElement };\n","function isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n","/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nexport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };\n","import { useMemo, useContext } from 'react';\nimport { MotionContext } from './index.mjs';\nimport { getCurrentTreeVariants } from './utils.mjs';\n\nfunction useCreateMotionContext(props) {\n    var _a = getCurrentTreeVariants(props, useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/variants.mjs';\n\nfunction getCurrentTreeVariants(props, context) {\n    if (checkIfControllingVariants(props)) {\n        var initial = props.initial, animate = props.animate;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nexport { getCurrentTreeVariants };\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nexport { globalProjectionState };\n","import { useConstant } from '../../utils/use-constant.mjs';\nimport { globalProjectionState } from './state.mjs';\n\nvar id = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id++;\n        }\n    });\n}\n\nexport { useProjectionId };\n","import { createContext } from 'react';\n\nvar LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","import { createContext } from 'react';\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\n","import { __extends } from 'tslib';\nimport React__default from 'react';\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    __extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default.Component));\n\nexport { VisualElementHandler };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { forwardRef, useContext } from 'react';\nimport { useFeatures } from './features/use-features.mjs';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { MotionContext } from '../context/MotionContext/index.mjs';\nimport { useVisualElement } from './utils/use-visual-element.mjs';\nimport { useMotionRef } from './utils/use-motion-ref.mjs';\nimport { useCreateMotionContext } from '../context/MotionContext/create.mjs';\nimport { loadFeatures, featureDefinitions } from './features/definitions.mjs';\nimport { isBrowser } from '../utils/is-browser.mjs';\nimport { useProjectionId } from '../projection/node/id.mjs';\nimport { LayoutGroupContext } from '../context/LayoutGroupContext.mjs';\nimport { useProjection } from './features/use-projection.mjs';\nimport { VisualElementHandler } from './utils/VisualElementHandler.mjs';\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = __assign(__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, __assign(__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React.createElement(VisualElementHandler, { visualElement: context.visualElement, props: __assign(__assign({}, config), props) },\n            features,\n            React.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\n\nexport { createMotionComponent };\n","import { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { useContext } from 'react';\nimport { SwitchLayoutGroupContext } from '../../context/SwitchLayoutGroupContext.mjs';\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.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: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nexport { useProjection };\n","import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\nexport { useMotionRef };\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        if (customMotionComponentConfig === void 0) { 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    var 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: function (_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 */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\n","var scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n","import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","var isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nexport { isMotionValue };\n","import { sortTransformProps } from './transform.mjs';\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\nexport { buildTransform, buildTransformOrigin };\n","/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable(key) {\n    return key.startsWith(\"--\");\n}\n\nexport { isCSSVariable };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","const clamp = (min, max) => (v) => Math.max(Math.min(v, max), min);\nconst sanitize = (v) => (v % 1 ? Number(v.toFixed(5)) : v);\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nexport { clamp, colorRegex, floatRegex, isString, sanitize, singleColorRegex };\n","import { isString } from '../utils.mjs';\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(' ').length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType('deg');\nconst percent = createUnitType('%');\nconst px = createUnitType('px');\nconst vh = createUnitType('vh');\nconst vw = createUnitType('vw');\nconst progressPercentage = Object.assign(Object.assign({}, percent), { parse: (v) => percent.parse(v) / 100, transform: (v) => percent.transform(v * 100) });\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","import { clamp } from '../utils.mjs';\n\nconst number = {\n    test: (v) => typeof v === 'number',\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = Object.assign(Object.assign({}, number), { transform: clamp(0, 1) });\nconst scale = Object.assign(Object.assign({}, number), { default: 1 });\n\nexport { alpha, number, scale };\n","import { __assign } from 'tslib';\nimport { number } from 'style-value-types';\n\nvar int = __assign(__assign({}, number), { transform: Math.round });\n\nexport { int };\n","import { px, degrees, scale, alpha, progressPercentage } from 'style-value-types';\nimport { int } from './type-int.mjs';\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\n","import { buildTransform, buildTransformOrigin } from './build-transform.mjs';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.mjs';\nimport { isTransformProp, isTransformOriginProp } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nexport { buildHTMLStyles };\n","var createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\n\nexport { createHtmlRenderState };\n","import { __assign } from 'tslib';\nimport { 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 (var key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues(_a, visualState, isStatic) {\n    var transformTemplate = _a.transformTemplate;\n    return useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return __assign(__assign({}, vars), style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    var styleProp = props.style || {};\n    var 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    if (props.transformValues) {\n        style = props.transformValues(style);\n    }\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    var htmlProps = {};\n    var style = useStyle(props, visualState, isStatic);\n    if (Boolean(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-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps, useStyle };\n","/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nexport { isValidMotionProp };\n","import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\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    var filteredProps = {};\n    for (var key in props) {\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\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps, loadExternalIsValidProp };\n","import { px } from 'style-value-types';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    var pathLength = px.transform(length);\n    var pathSpacing = px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = __rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","import { __assign } from 'tslib';\nimport { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';\n\nvar createSvgRenderState = function () { return (__assign(__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nexport { createSvgRenderState };\n","import { __assign } from 'tslib';\nimport { 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';\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return __assign(__assign({}, state.attrs), { style: __assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = __assign(__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nexport { useSVGProps };\n","import { __assign } from 'tslib';\nimport { 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';\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = __assign(__assign(__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\n        return createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nexport { createUseRender };\n","var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nexport { camelToDash };\n","function renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nexport { camelCaseAttributes };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","function isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nexport { isAnimationControls };\n","var isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n","import { __rest } from 'tslib';\nimport { useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, resolveVariantFromProps } from '../../render/utils/variants.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { MotionContext } from '../../context/MotionContext/index.mjs';\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) {\n    return function (props, isStatic) {\n        var context = useContext(MotionContext);\n        var presenceContext = useContext(PresenceContext);\n        return isStatic\n            ? makeState(config, props, context, presenceContext)\n            : useConstant(function () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = __rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\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';\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\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            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nexport { svgMotionConfig };\n","var AnimationType;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\n","import { 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\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","function isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\nexport { isMouseEvent, isTouchEvent };\n","import { isTouchEvent } from '../gestures/utils/event-type.mjs';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, wrapHandler };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nexport { addPointerEvent, usePointerEvent };\n","import { isBrowser } from '../utils/is-browser.mjs';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","function createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { isMouseEvent } from './utils/event-type.mjs';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\nexport { useHoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\n","const combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","var warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n","import { __rest, __assign } from 'tslib';\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = __rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, __assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { env } from '../../../utils/process.mjs';\nimport { useRef, useEffect } from 'react';\nimport { AnimationType } from '../../../render/utils/types.mjs';\nimport { warnOnce } from '../../../utils/warn-once.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nexport { useViewport };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.mjs';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.mjs';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.mjs';\nimport { useViewport } from './viewport/use-viewport.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = useRef(false);\n    var cancelPointerEndListeners = useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.mjs';\nimport { useDomEvent } from '../events/use-dom-event.mjs';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nexport { useFocusGesture };\n","import { useConstant } from './use-constant.mjs';\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\nexport { useId };\n","import { useContext, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useId } from '../../utils/use-id.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    var context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    var id = useId();\n    useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","import { warning } from 'hey-listen';\nimport { clamp } from '../../utils/clamp.mjs';\n\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = duration * 1000;\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: 100,\n            damping: 10,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };\n","import { __rest } from 'tslib';\nimport { findSpring, calcAngularFreq } from '../utils/find-spring.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = Object.assign({ velocity: 0.0, stiffness: 100, damping: 10, mass: 1.0, isResolvedFromDuration: false }, options);\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = Object.assign(Object.assign(Object.assign({}, springOptions), derived), { velocity: 0.0, mass: 1.0 });\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring(_a) {\n    var { from = 0.0, to = 1.0, restSpeed = 2, restDelta } = _a, options = __rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n    const state = { done: false, value: from };\n    let { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let resolveVelocity = zero;\n    function createSpring() {\n        const initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n        const initialDelta = to - from;\n        const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        if (restDelta === undefined) {\n            restDelta = Math.min(Math.abs(to - from) / 100, 0.4);\n        }\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (to -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n            resolveVelocity = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (dampingRatio *\n                    undampedAngularFreq *\n                    envelope *\n                    ((Math.sin(angularFreq * t) *\n                        (initialVelocity +\n                            dampingRatio *\n                                undampedAngularFreq *\n                                initialDelta)) /\n                        angularFreq +\n                        initialDelta * Math.cos(angularFreq * t)) -\n                    envelope *\n                        (Math.cos(angularFreq * t) *\n                            (initialVelocity +\n                                dampingRatio *\n                                    undampedAngularFreq *\n                                    initialDelta) -\n                            angularFreq *\n                                initialDelta *\n                                Math.sin(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            resolveSpring = (t) => to -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (to -\n                    (envelope *\n                        ((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) *\n                            Math.sinh(freqForT) +\n                            dampedAngularFreq *\n                                initialDelta *\n                                Math.cosh(freqForT))) /\n                        dampedAngularFreq);\n            };\n        }\n    }\n    createSpring();\n    return {\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = resolveVelocity(t) * 1000;\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? to : current;\n            return state;\n        },\n        flipTarget: () => {\n            velocity = -velocity;\n            [from, to] = [to, from];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nexport { spring };\n","const progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","const mix = (from, to, progress) => -progress * from + progress * to + from;\n\nexport { mix };\n","import { isString, singleColorRegex, floatRegex } from '../utils.mjs';\n\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { number, alpha } from '../numbers/index.mjs';\nimport { sanitize, clamp } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = clamp(0, 255);\nconst rgbUnit = Object.assign(Object.assign({}, number), { transform: (v) => Math.round(clampRgbUnit(v)) });\nconst rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => 'rgba(' +\n        rgbUnit.transform(red) +\n        ', ' +\n        rgbUnit.transform(green) +\n        ', ' +\n        rgbUnit.transform(blue) +\n        ', ' +\n        sanitize(alpha.transform(alpha$1)) +\n        ')',\n};\n\nexport { rgbUnit, rgba };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = '';\n    let g = '';\n    let b = '';\n    let a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nexport { hsla };\n","function hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","import { mix } from './mix.mjs';\nimport { hsla, rgba, hex } from 'style-value-types';\nimport { invariant } from 'hey-listen';\nimport { hslaToRgba } from './hsla-to-rgba.mjs';\n\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const toExpo = to * to;\n    return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nconst notAnimatable = (color) => `'${color}' is not an animatable color. Use the equivalent color code instead.`;\nconst mixColor = (from, to) => {\n    let fromColorType = getColorType(from);\n    let toColorType = getColorType(to);\n    invariant(!!fromColorType, notAnimatable(from));\n    invariant(!!toColorType, notAnimatable(to));\n    let fromColor = fromColorType.parse(from);\n    let toColor = toColorType.parse(to);\n    if (fromColorType === hsla) {\n        fromColor = hslaToRgba(fromColor);\n        fromColorType = rgba;\n    }\n    if (toColorType === hsla) {\n        toColor = hslaToRgba(toColor);\n        toColorType = rgba;\n    }\n    const blended = Object.assign({}, fromColor);\n    return (v) => {\n        for (const key in blended) {\n            if (key !== \"alpha\") {\n                blended[key] = mixLinearColor(fromColor[key], toColor[key], v);\n            }\n        }\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n        return fromColorType.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { color } from '../color/index.mjs';\nimport { number } from '../numbers/index.mjs';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.mjs';\n\nconst colorToken = '${c}';\nconst numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    if (typeof v === 'number')\n        v = `${v}`;\n    const values = [];\n    let numColors = 0;\n    const colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push(...colors.map(color.parse));\n    }\n    const numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push(...numbers.map(number.parse));\n    }\n    return { values, numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    const { values, numColors, tokenised } = analyse(v);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === 'number' ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parse(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = { test, parse, createTransformer, getAnimatableNone };\n\nexport { complex };\n","const zeroPoint = {\n    x: 0,\n    y: 0,\n    z: 0\n};\nconst isNum = (v) => typeof v === 'number';\n\nexport { isNum, zeroPoint };\n","import { complex, color } from 'style-value-types';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { isNum } from './inc.mjs';\nimport { pipe } from './pipe.mjs';\nimport { warning } from 'hey-listen';\n\nfunction getMixer(origin, target) {\n    if (isNum(origin)) {\n        return (v) => mix(origin, target, v);\n    }\n    else if (color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return mixComplex(origin, target);\n    }\n}\nconst mixArray = (from, to) => {\n    const output = [...from];\n    const numValues = output.length;\n    const blendValue = from.map((fromThis, i) => getMixer(fromThis, to[i]));\n    return (v) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](v);\n        }\n        return output;\n    };\n};\nconst mixObject = (origin, target) => {\n    const output = Object.assign(Object.assign({}, origin), target);\n    const blendValue = {};\n    for (const key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(origin[key], target[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n};\nfunction analyse(value) {\n    const parsed = complex.parse(value);\n    const numValues = parsed.length;\n    let numNumbers = 0;\n    let numRGB = 0;\n    let numHSL = 0;\n    for (let i = 0; i < numValues; i++) {\n        if (numNumbers || typeof parsed[i] === \"number\") {\n            numNumbers++;\n        }\n        else {\n            if (parsed[i].hue !== undefined) {\n                numHSL++;\n            }\n            else {\n                numRGB++;\n            }\n        }\n    }\n    return { parsed, numNumbers, numRGB, numHSL };\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyse(origin);\n    const targetStats = analyse(target);\n    const canInterpolate = originStats.numHSL === targetStats.numHSL &&\n        originStats.numRGB === targetStats.numRGB &&\n        originStats.numNumbers >= targetStats.numNumbers;\n    if (canInterpolate) {\n        return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return (p) => `${p > 0 ? target : origin}`;\n    }\n};\n\nexport { mixArray, mixComplex, mixObject };\n","import { progress } from './progress.mjs';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.mjs';\nimport { color } from 'style-value-types';\nimport { clamp } from './clamp.mjs';\nimport { pipe } from './pipe.mjs';\nimport { invariant } from 'hey-listen';\n\nconst mixNumber = (from, to) => (p) => mix(from, to, p);\nfunction detectMixerFactory(v) {\n    if (typeof v === 'number') {\n        return mixNumber;\n    }\n    else if (typeof v === 'string') {\n        if (color.test(v)) {\n            return mixColor;\n        }\n        else {\n            return mixComplex;\n        }\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === 'object') {\n        return mixObject;\n    }\n}\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || detectMixerFactory(output[0]);\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\nfunction fastInterpolate([from, to], [mixer]) {\n    return (v) => mixer(progress(from, to, v));\n}\nfunction slowInterpolate(input, mixers) {\n    const inputLength = input.length;\n    const lastInputIndex = inputLength - 1;\n    return (v) => {\n        let mixerIndex = 0;\n        let foundMixerIndex = false;\n        if (v <= input[0]) {\n            foundMixerIndex = true;\n        }\n        else if (v >= input[lastInputIndex]) {\n            mixerIndex = lastInputIndex - 1;\n            foundMixerIndex = true;\n        }\n        if (!foundMixerIndex) {\n            let i = 1;\n            for (; i < inputLength; i++) {\n                if (input[i] > v || i === lastInputIndex) {\n                    break;\n                }\n            }\n            mixerIndex = i - 1;\n        }\n        const progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n        return mixers[mixerIndex](progressInRange);\n    };\n}\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n    invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n    if (input[0] > input[inputLength - 1]) {\n        input = [].concat(input);\n        output = [].concat(output);\n        input.reverse();\n        output.reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const interpolator = inputLength === 2\n        ? fastInterpolate(input, mixers)\n        : slowInterpolate(input, mixers);\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","const reverseEasing = easing => p => 1 - easing(1 - p);\nconst mirrorEasing = easing => p => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\nconst createExpoIn = (power) => p => Math.pow(p, power);\nconst createBackIn = (power) => p => p * p * ((power + 1) * p - power);\nconst createAnticipate = (power) => {\n    const backEasing = createBackIn(power);\n    return p => (p *= 2) < 1\n        ? 0.5 * backEasing(p)\n        : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n};\n\nexport { createAnticipate, createBackIn, createExpoIn, mirrorEasing, reverseEasing };\n","import { createExpoIn, reverseEasing, mirrorEasing, createBackIn, createAnticipate } from './utils.mjs';\n\nconst DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nconst BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nconst BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nconst BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nconst linear = p => p;\nconst easeIn = createExpoIn(2);\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\nconst circIn = p => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\nconst backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nconst backOut = reverseEasing(backIn);\nconst backInOut = mirrorEasing(backIn);\nconst anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nconst ca = 4356.0 / 361.0;\nconst cb = 35442.0 / 1805.0;\nconst cc = 16061.0 / 1805.0;\nconst bounceOut = (p) => {\n    if (p === 1 || p === 0)\n        return p;\n    const p2 = p * p;\n    return p < BOUNCE_FIRST_THRESHOLD\n        ? 7.5625 * p2\n        : p < BOUNCE_SECOND_THRESHOLD\n            ? 9.075 * p2 - 9.9 * p + 3.4\n            : p < BOUNCE_THIRD_THRESHOLD\n                ? ca * p2 - cb * p + cc\n                : 10.8 * p * p - 20.52 * p + 10.72;\n};\nconst bounceIn = reverseEasing(bounceOut);\nconst bounceInOut = (p) => p < 0.5\n    ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0))\n    : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n\nexport { anticipate, backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, easeIn, easeInOut, easeOut, linear };\n","import { interpolate } from '../../utils/interpolate.mjs';\nimport { easeInOut } from '../../easing/index.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n    const numValues = values.length;\n    return values.map((_value, i) => i !== 0 ? i / (numValues - 1) : 0);\n}\nfunction convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\nfunction keyframes({ from = 0, to = 1, ease, offset, duration = 300, }) {\n    const state = { done: false, value: from };\n    const values = Array.isArray(to) ? to : [from, to];\n    const times = convertOffsetToTimes(offset && offset.length === values.length\n        ? offset\n        : defaultOffset(values), duration);\n    function createInterpolator() {\n        return interpolate(times, values, {\n            ease: Array.isArray(ease) ? ease : defaultEasing(values, ease),\n        });\n    }\n    let interpolator = createInterpolator();\n    return {\n        next: (t) => {\n            state.value = interpolator(t);\n            state.done = t >= duration;\n            return state;\n        },\n        flipTarget: () => {\n            values.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { convertOffsetToTimes, defaultEasing, defaultOffset, keyframes };\n","import { spring } from '../generators/spring.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { decay } from '../generators/decay.mjs';\n\nconst types = { keyframes, spring, decay };\nfunction detectAnimationFromOptions(config) {\n    if (Array.isArray(config.to)) {\n        return keyframes;\n    }\n    else if (types[config.type]) {\n        return types[config.type];\n    }\n    const keys = new Set(Object.keys(config));\n    if (keys.has(\"ease\") ||\n        (keys.has(\"duration\") && !keys.has(\"dampingRatio\"))) {\n        return keyframes;\n    }\n    else if (keys.has(\"dampingRatio\") ||\n        keys.has(\"stiffness\") ||\n        keys.has(\"mass\") ||\n        keys.has(\"damping\") ||\n        keys.has(\"restSpeed\") ||\n        keys.has(\"restDelta\")) {\n        return spring;\n    }\n    return keyframes;\n}\n\nexport { detectAnimationFromOptions };\n","function decay({ velocity = 0, from = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const state = { done: false, value: from };\n    let amplitude = power * velocity;\n    const ideal = from + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    if (target !== ideal)\n        amplitude = target - from;\n    return {\n        next: (t) => {\n            const delta = -amplitude * Math.exp(-t / timeConstant);\n            state.done = !(delta > restDelta || delta < -restDelta);\n            state.value = state.done ? target : target + delta;\n            return state;\n        },\n        flipTarget: () => { },\n    };\n}\n\nexport { decay };\n","const defaultTimestep = (1 / 60) * 1000;\nconst getCurrentTime = typeof performance !== \"undefined\"\n    ? () => performance.now()\n    : () => Date.now();\nconst onNextFrame = typeof window !== \"undefined\"\n    ? (callback) => window.requestAnimationFrame(callback)\n    : (callback) => setTimeout(() => callback(getCurrentTime()), defaultTimestep);\n\nexport { defaultTimestep, onNextFrame };\n","import { onNextFrame, defaultTimestep } from './on-next-frame.mjs';\nimport { createRenderStep } from './create-render-step.mjs';\n\nconst maxElapsed = 40;\nlet useDefaultElapsed = true;\nlet runNextFrame = false;\nlet isProcessing = false;\nconst frame = {\n    delta: 0,\n    timestamp: 0,\n};\nconst stepsOrder = [\n    \"read\",\n    \"update\",\n    \"preRender\",\n    \"render\",\n    \"postRender\",\n];\nconst steps = stepsOrder.reduce((acc, key) => {\n    acc[key] = createRenderStep(() => (runNextFrame = true));\n    return acc;\n}, {});\nconst sync = stepsOrder.reduce((acc, key) => {\n    const step = steps[key];\n    acc[key] = (process, keepAlive = false, immediate = false) => {\n        if (!runNextFrame)\n            startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nconst cancelSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nconst flushSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = () => steps[key].process(frame);\n    return acc;\n}, {});\nconst processStep = (stepId) => steps[stepId].process(frame);\nconst processFrame = (timestamp) => {\n    runNextFrame = false;\n    frame.delta = useDefaultElapsed\n        ? defaultTimestep\n        : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n    frame.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nconst startLoop = () => {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing)\n        onNextFrame(processFrame);\n};\nconst getFrameData = () => frame;\n\nexport default sync;\nexport { cancelSync, flushSync, getFrameData };\n","function createRenderStep(runNextFrame) {\n    let toRun = [];\n    let toRunNextFrame = [];\n    let numToRun = 0;\n    let isProcessing = false;\n    let flushNextFrame = false;\n    const toKeepAlive = new WeakSet();\n    const step = {\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        cancel: (callback) => {\n            const index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        process: (frameData) => {\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [toRun, toRunNextFrame] = [toRunNextFrame, toRun];\n            toRunNextFrame.length = 0;\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","function loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, delay = 0, isForwardPlayback = true) {\n    return isForwardPlayback\n        ? loopElapsed(duration + -elapsed, duration, delay)\n        : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n    return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\n\nexport { hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","import { __rest } from 'tslib';\nimport { detectAnimationFromOptions } from './utils/detect-animation-from-options.mjs';\nimport sync, { cancelSync } from 'framesync';\nimport { interpolate } from '../utils/interpolate.mjs';\nimport { hasRepeatDelayElapsed, reverseElapsed, loopElapsed } from './utils/elapsed.mjs';\n\nconst framesync = (update) => {\n    const passTimestamp = ({ delta }) => update(delta);\n    return {\n        start: () => sync.update(passTimestamp, true),\n        stop: () => cancelSync.update(passTimestamp),\n    };\n};\nfunction animate(_a) {\n    var _b, _c;\n    var { from, autoplay = true, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, onPlay, onStop, onComplete, onRepeat, onUpdate } = _a, options = __rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n    let { to } = options;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = options.duration;\n    let latest;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = detectAnimationFromOptions(options);\n    if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n        interpolateFromNumber = interpolate([0, 100], [from, to], {\n            clamp: false,\n        });\n        from = 0;\n        to = 100;\n    }\n    const animation = animator(Object.assign(Object.assign({}, options), { from, to }));\n    function repeat() {\n        repeatCount++;\n        if (repeatType === \"reverse\") {\n            isForwardPlayback = repeatCount % 2 === 0;\n            elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n        }\n        else {\n            elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n            if (repeatType === \"mirror\")\n                animation.flipTarget();\n        }\n        isComplete = false;\n        onRepeat && onRepeat();\n    }\n    function complete() {\n        driverControls.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            const state = animation.next(Math.max(0, elapsed));\n            latest = state.value;\n            if (interpolateFromNumber)\n                latest = interpolateFromNumber(latest);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n        if (isComplete) {\n            if (repeatCount === 0)\n                computedDuration !== null && computedDuration !== void 0 ? computedDuration : (computedDuration = elapsed);\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop === null || onStop === void 0 ? void 0 : onStop();\n            driverControls.stop();\n        },\n    };\n}\n\nexport { animate };\n","function velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) { return seconds * 1000; };\n\nexport { secondsToMilliseconds };\n","import { linear } from './index.mjs';\n\nconst a = (a1, a2) => 1.0 - 3.0 * a2 + 3.0 * a1;\nconst b = (a1, a2) => 3.0 * a2 - 6.0 * a1;\nconst c = (a1) => 3.0 * a1;\nconst calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\nconst getSlope = (t, a1, a2) => 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = aA + (aB - aA) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - aX;\n        if (currentX > 0.0) {\n            aB = currentT;\n        }\n        else {\n            aA = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nconst newtonIterations = 8;\nconst newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n    for (let i = 0; i < newtonIterations; ++i) {\n        const currentSlope = getSlope(aGuessT, mX1, mX2);\n        if (currentSlope === 0.0) {\n            return aGuessT;\n        }\n        const currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n        aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n}\nconst kSplineTableSize = 11;\nconst kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    if (mX1 === mY1 && mX2 === mY2)\n        return linear;\n    const sampleValues = new Float32Array(kSplineTableSize);\n    for (let i = 0; i < kSplineTableSize; ++i) {\n        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n    }\n    function getTForX(aX) {\n        let intervalStart = 0.0;\n        let currentSample = 1;\n        const lastSample = kSplineTableSize - 1;\n        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        const dist = (aX - sampleValues[currentSample]) /\n            (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n        const guessForT = intervalStart + dist * kSampleStepSize;\n        const initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= newtonMinSlope) {\n            return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n        }\n        else if (initialSlope === 0.0) {\n            return guessForT;\n        }\n        else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n        }\n    }\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { cubicBezier, linear, easeIn, easeInOut, easeOut, circIn, circInOut, circOut, backIn, backInOut, backOut, anticipate, bounceIn, bounceInOut, bounceOut } from 'popmotion';\n\nvar easingLookup = {\n    linear: linear,\n    easeIn: easeIn,\n    easeInOut: easeInOut,\n    easeOut: easeOut,\n    circIn: circIn,\n    circInOut: circInOut,\n    circOut: circOut,\n    backIn: backIn,\n    backInOut: backInOut,\n    backOut: backOut,\n    anticipate: anticipate,\n    bounceIn: bounceIn,\n    bounceInOut: bounceInOut,\n    bounceOut: bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = __read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\".concat(definition, \"'\"));\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { easingDefinitionToFunction, isEasingArray };\n","import { complex } from 'style-value-types';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nvar isAnimatable = function (key, value) {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        complex.test(value) && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nexport { isAnimatable };\n","import { __assign } from 'tslib';\nimport { isKeyframesTarget } from './is-keyframes-target.mjs';\n\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\n}); };\nvar defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return __assign({ to: to }, transitionFactory(to));\n};\n\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\nconst maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    let [name, value] = v.slice(0, -1).split('(');\n    if (name === 'drop-shadow')\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, '');\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + '(' + defaultValue + unit + ')';\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = Object.assign(Object.assign({}, complex), { getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexport { filter };\n","import { __assign } from 'tslib';\nimport { color, filter } from 'style-value-types';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = __assign(__assign({}, numberValueTypes), { \n    // Color props\n    color: color, backgroundColor: color, outlineColor: color, fill: color, stroke: color, \n    // Border props\n    borderColor: color, borderTopColor: color, borderRightColor: color, borderBottomColor: color, borderLeftColor: color, filter: filter, WebkitFilter: filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nexport { defaultValueTypes, getDefaultValueType };\n","import { filter, complex } from 'style-value-types';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nexport { getAnimatableNone };\n","var instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","import { __assign, __rest, __spreadArray, __read } from 'tslib';\nimport { inertia, animate } from 'popmotion';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { isEasingArray, easingDefinitionToFunction } from './easing.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { getDefaultTransition } from './default-transitions.mjs';\nimport { warning } from 'hey-listen';\nimport { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\n\n/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined(_a) {\n    _a.when; _a.delay; _a.delayChildren; _a.staggerChildren; _a.staggerDirection; _a.repeat; _a.repeatType; _a.repeatDelay; _a.from; var transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n    return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n    var ease = _a.ease, times = _a.times, yoyo = _a.yoyo, flip = _a.flip, loop = _a.loop, transition = __rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = __assign({}, transition);\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a, _b;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = __spreadArray([], __read(options.to), false);\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = __assign(__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return __assign(__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key);\n    var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n    var isTargetAnimatable = isAnimatable(key, target);\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(key, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    var isOriginAnimatable = isAnimatable(key, origin);\n    warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \".concat(key, \" from \\\"\").concat(origin, \"\\\" to \\\"\").concat(target, \"\\\". \").concat(origin, \" is not an animatable value - to enable this animation set \").concat(origin, \" to a value animatable to \").concat(target, \" via the `style` property.\"));\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? inertia(__assign(__assign({}, options), valueTransition))\n            : animate(__assign(__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: function (v) {\n                    var _a;\n                    options.onUpdate(v);\n                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n                }, onComplete: function () {\n                    var _a;\n                    options.onComplete();\n                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n                } }));\n    }\n    function set() {\n        var _a, _b;\n        var finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);\n        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = window.setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\n}\n\nexport { convertTransitionToAnimationOptions, getDelayFromTransition, getPopmotionAnimationOptions, getValueTransition, getZeroUnit, hydrateKeyframes, isTransitionDefined, isZero, startAnimation };\n","import { animate } from './index.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { getFrameData } from 'framesync';\n\nfunction inertia({ from = 0, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function boundaryNearest(v) {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    }\n    function startAnimation(options) {\n        currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate(Object.assign(Object.assign({}, options), { driver, onUpdate: (v) => {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            }, onComplete,\n            onStop }));\n    }\n    function startSpring(options) {\n        startAnimation(Object.assign({ type: \"spring\", stiffness: bounceStiffness, damping: bounceDamping, restDelta }, options));\n    }\n    if (isOutOfBounds(from)) {\n        startSpring({ from, velocity, to: boundaryNearest(from) });\n    }\n    else {\n        let target = power * velocity + from;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = boundaryNearest(target);\n        const heading = boundary === min ? -1 : 1;\n        let prev;\n        let current;\n        const checkBoundary = (v) => {\n            prev = current;\n            current = v;\n            velocity = velocityPerSecond(v - prev, getFrameData().delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ from: v, to: boundary, velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            from,\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nexport { isZeroValueString };\n","import { __read } from 'tslib';\n\nfunction addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_a, fromIndex, toIndex) {\n    var _b = __read(_a), arr = _b.slice(0);\n    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        var _c = __read(arr.splice(fromIndex, 1), 1), item = _c[0];\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (var i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nexport { SubscriptionManager };\n","import sync, { getFrameData } from 'framesync';\nimport { velocityPerSecond } from 'popmotion';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    function MotionValue(init) {\n        var _this = this;\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"6.5.1\";\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync.postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.notify(_this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = function () { return sync.postRender(_this.velocityCheck); };\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @privateRemarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\n    };\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\n        return this.prev;\n    };\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\n    };\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\n    };\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\nexport { MotionValue, motionValue };\n","/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\nexport { testValueType };\n","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\nexport { auto };\n","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes), false), [color, complex], false);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\n\nexport { findValueType };\n","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = __rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = __assign(__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = __spreadArray([], __read(variantLabels), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { setTarget } from './setters.mjs';\nimport { resolveVariant } from './variants.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\n\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return Promise.resolve(); };\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return Promise.resolve(); };\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    var when = transition.when;\n    if (when) {\n        var _c = __read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = __rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var valueTransition = __assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = __assign(__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, __assign(__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","import { __spreadArray, __read, __assign, __rest } from 'tslib';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { AnimationType } from './types.mjs';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.mjs';\n\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = __rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = __assign(__assign(__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\n    }\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        var animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        var removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        var encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            var activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = __assign({}, encounteredKeys);\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                return \"continue\";\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            var variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = __assign(__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = __assign(__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, __spreadArray([], __read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: __assign({ type: type }, options),\n                }); })), false));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = __assign({}, encounteredKeys);\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[AnimationType.Animate] = createTypeState(true),\n        _a[AnimationType.InView] = createTypeState(),\n        _a[AnimationType.Hover] = createTypeState(),\n        _a[AnimationType.Tap] = createTypeState(),\n        _a[AnimationType.Drag] = createTypeState(),\n        _a[AnimationType.Focus] = createTypeState(),\n        _a[AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nexport { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { createAnimationState } from '../../render/utils/animation-state.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","const isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nexport { isPoint };\n","import { isPoint } from './is-point.mjs';\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.mjs';\nimport { isPoint3D } from './is-point-3d.mjs';\nimport { isNum } from './inc.mjs';\n\nconst distance1D = (a, b) => Math.abs(a - b);\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        const xDelta = distance1D(a.x, b.x);\n        const yDelta = distance1D(a.y, b.y);\n        const zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nexport { distance };\n","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\n","import { mix, distance } from 'popmotion';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = __read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { hasScale, hasTransform };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    var distanceFromOrigin = point - originPoint;\n    var scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys);\n    transformAxis(box.y, transform, yKeys);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = __assign(__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return __assign(__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n","var createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","import { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = useRef(null);\n    var transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\n","import { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, __spreadArray([], __read(args), false));\n        };\n    });\n    return lifecycles;\n}\n\nexport { createLifecycles };\n","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { createLifecycles } from './utils/lifecycles.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.mjs';\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = __assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync.update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = __assign(__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                cancelSync.update(update);\n                cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            }, \n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\n            }, \n            /**\n             * Measure the current viewport box with or without transforms.\n             * Only measures axis-aligned boxes, rotate and skew must be manually\n             * removed with a re-render to work.\n             */\n            measureViewportBox: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \n            /**\n             * If we're trying to animate to a previously unencountered value,\n             * we need to check for it in our state and as a last resort read it\n             * directly from the instance (which might have performance implications).\n             */\n            readValue: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n            }, \n            /**\n             * Set the base target to later animate back to. This is currently\n             * only hydrated on creation and when we first read a value.\n             */\n            setBaseTarget: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync.render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \n            /**\n             * Update the provided props. Ensure any newly-added motion values are\n             * added to our map, old ones removed, and listeners updated.\n             */\n            setProps: function (newProps) {\n                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nexport { visualElement };\n","import { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { __rest, __assign, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = __read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\".concat(current, \"\\\". This may indicate a circular fallback dependency.\"));\n    var _a = __read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = __rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof Element))\n        return { target: target, transitionEnd: transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = __assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === number || v === px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (key) {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = __assign({}, target);\n    transitionEnd = __assign({}, transitionEnd);\n    var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var fromType = findDimensionValueType(from);\n        var to = target[key];\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                var current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = __read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\nexport { BoundingBoxDimension, positionalValues, unitConversion };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs';\nimport { isTransformProp } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle(domElement);\n            return ((isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    },\n    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return __assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n","import { __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { htmlConfig } from '../html/visual-element.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\n\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nexport { svgVisualElement };\n","import { htmlVisualElement } from '../html/visual-element.mjs';\nimport { svgVisualElement } from '../svg/visual-element.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(__assign(__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\n","import { mix, progress, linear, circOut } from 'popmotion';\nimport { px, percent } from 'style-value-types';\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, linear);\nfunction compress(min, max, easing) {\n    return function (p) {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\n","/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\nexport { copyAxisInto, copyBoxInto };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { scalePoint } from './delta-apply.mjs';\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a, origin, sourceAxis) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","function isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nexport { boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nexport { NodeStack };\n","var identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nexport { buildProjectionTransform, identityProjection };\n","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\nexport { FlatTree };\n","import { __spreadArray, __read, __assign } from 'tslib';\nimport sync, { cancelSync, flushSync } from 'framesync';\nimport { mix } from 'popmotion';\nimport { animate } from '../../animation/animate.mjs';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEquals, isDeltaZero } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale } from '../utils/has-transform.mjs';\nimport { transformAxes } from '../../render/html/utils/transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\n\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? __spreadArray(__spreadArray([], __read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, __spreadArray([], __read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = __assign(__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync.preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync.postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = __assign(__assign(__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = __assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync.update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, __assign(__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = mix(delta.translate, 0, p);\n    output.scale = mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = mix(from.min, to.min, p);\n    output.max = mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nexport { createProjectionNode, mixAxis, mixAxisDelta, mixBox };\n","import { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { startAnimation } from './utils/transitions.mjs';\n\n/**\n * Animate a single value or a `MotionValue`.\n *\n * The first argument is either a `MotionValue` to animate, or an initial animation value.\n *\n * The second is either a value to animate to, or an array of keyframes to animate through.\n *\n * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.\n *\n * Returns `AnimationPlaybackControls`, currently just a `stop` method.\n *\n * ```javascript\n * const x = useMotionValue(0)\n *\n * useEffect(() => {\n *   const controls = animate(x, 100, {\n *     type: \"spring\",\n *     stiffness: 2000,\n *     onComplete: v => {}\n *   })\n *\n *   return controls.stop\n * })\n * ```\n *\n * @public\n */\nfunction animate(from, to, transition) {\n    if (transition === void 0) { transition = {}; }\n    var value = isMotionValue(from) ? from : motionValue(from);\n    startAnimation(\"\", value, to, transition);\n    return {\n        stop: function () { return value.stop(); },\n        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { 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 { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\nvar featureBundle = __assign(__assign(__assign(__assign({}, animations), gestureAnimations), drag), layoutFeatures);\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 */\nvar motion = /*@__PURE__*/ createMotionProxy(function (Component, config) {\n    return createDomMotionConfig(Component, config, featureBundle, createDomVisualElement, HTMLProjectionNode);\n});\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 }, featureBundle, createDomVisualElement, HTMLProjectionNode));\n}\n\nexport { createDomMotionComponent, motion };\n","import { __assign } from 'tslib';\nimport { 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, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return __assign(__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexport { createDomMotionConfig };\n","var isBrowser = typeof document !== \"undefined\";\n\nexport { isBrowser };\n","import { __read } from 'tslib';\nimport { useState, useContext } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { isBrowser } from './is-browser.mjs';\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = __read(useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nexport { useReducedMotion, useReducedMotionConfig };\n"],"names":["MotionConfigContext","createContext","transformPagePoint","p","isStatic","reducedMotion","createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","inView","LazyContext","strict","featureNames","Object","keys","numFeatures","length","MotionContext","useIsomorphicLayoutEffect","useLayoutEffect","useEffect","useVisualElement","Component","visualState","createVisualElement","lazyContext","useContext","parent","visualElement","presenceContext","shouldReduceMotion","visualElementRef","useRef","undefined","renderer","current","presenceId","id","blockInitialAnimation","initial","syncRender","_a","animationState","animateChanges","notifyUnmount","isRefObject","ref","prototype","hasOwnProperty","call","isVariantLabels","v","Array","isArray","isVariantLabel","resolveVariantFromProps","definition","custom","currentValues","currentVelocity","variants","resolveVariant","getProps","forEachValue","value","key","get","getCurrent","velocity","getVelocity","checkIfControllingVariants","animate","start","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","Boolean","useCreateMotionContext","context","inherit","getCurrentTreeVariants","useMemo","variantLabelsAsDependency","prop","join","useConstant","init","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","LayoutGroupContext","SwitchLayoutGroupContext","VisualElementHandler","_super","apply","this","arguments","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","setProps","render","children","preloadedFeatures","projectionNodeConstructor","useRender","useVisualState","features","loadFeatures","forwardRef","externalRef","layoutId","_b","layoutGroupId","useLayoutId","config","projectionId","ProjectionNodeConstructor","layout","dragConstraints","layoutScroll","initialPromotionConfig","projection","getLatestValues","setOptions","alwaysMeasureLayout","scheduleRender","animationType","useProjection","i","name_1","push","useFeatures","Provider","useCallback","instance","mount","unmount","useMotionRef","createMotionProxy","createConfig","customMotionComponentConfig","Proxy","componentCache","Map","_target","has","set","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","scaleCorrectors","transformAxes","transformProps","sortTransformProps","a","b","forEach","operationKey","axesKey","transformPropSet","Set","isTransformProp","transformOriginProps","isTransformOriginProp","isForcedMotionValue","isMotionValue","translateAlias","x","y","z","transformPerspective","isCSSVariable","startsWith","getValueAsType","type","transform","clamp","min","max","Math","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString","createUnitType","unit","endsWith","split","parse","parseFloat","degrees","percent","px","vh","vw","progressPercentage","assign","number","alpha","scale","default","round","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","width","maxWidth","height","maxHeight","size","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","opacity","originX","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","buildHTMLStyles","state","latestValues","options","transformTemplate","style","vars","transformKeys","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","transformIsDefault","_c","enableHardwareAcceleration","_d","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","concat","trim","buildTransform","buildTransformOrigin","createHtmlRenderState","copyRawValuesOnly","target","source","useStyle","useInitialMotionValues","transformValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","validMotionProps","isValidMotionProp","isValidProp","shouldForward","require","calcOrigin","origin","offset","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","attrs","dimensions","pxOriginX","pxOriginY","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","createSvgRenderState","useSVGProps","visualProps","rawStyles","createUseRender","forwardMotionProps","filteredProps","isDom","filterProps","elementProps","createElement","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","renderHTML","element","styleProp","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps","newValues","toUpperCase","isAnimationControls","isKeyframesTarget","resolveFinalValueInKeyframes","resolveMotionValue","unwrappedValue","mix","toValue","makeState","createRenderState","onMount","makeLatestValues","makeUseVisualState","scrapeMotionValues","values","motionValues","isControllingVariants","isVariantNode","initialAnimationIsBlocked","variantToSet","resolved","transitionEnd","transition","valueTarget","AnimationType","svgMotionConfig","getBBox","getBoundingClientRect","e","htmlMotionConfig","addDomEvent","eventName","handler","passive","addEventListener","removeEventListener","useDomEvent","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","point","changedTouches","pointFromMouse","extractEventInfo","wrapHandler","shouldFilterPrimaryPointer","eventHandler","listener","button","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","window","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","createHoverEvent","isActive","callback","info","setActive","Hover","isNodeOrChild","child","parentElement","useUnmountEffect","combineFunctions","pipe","transformers","reduce","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","root","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","delete","unobserve","thresholdNames","all","useIntersectionObserver","shouldObserve","rootMargin","amount","once","threshold","getInstance","isIntersecting","isInView","hasEnteredView","InView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","fallback","requestAnimationFrame","makeRenderlessComponent","hook","gestureAnimations","whileInView","viewport","onTap","onTapStart","onTapCancel","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","Tap","onPointerUp","onPointerCancel","Focus","onHoverStart","onHoverEnd","counter","incrementId","usePresence","isPresent","onExitComplete","register","shallowCompare","next","prev","prevLength","safeMin","findSpring","duration","bounce","mass","envelope","derivative","dampingRatio","undampedFreq","exponentialDecay","delta","calcAngularFreq","c","exp","d","pow","f","g","initialGuess","result","rootIterations","approximateRoot","isNaN","stiffness","damping","sqrt","durationKeys","physicsKeys","isSpringType","spring","from","to","restSpeed","restDelta","done","isResolvedFromDuration","springOptions","derived","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","abs","angularFreq","t","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","progress","toFromDifference","isColorString","testProp","splitColor","aName","bName","cName","match","clampRgbUnit","rgbUnit","rgba","red","green","blue","alpha$1","hex","r","substr","parseInt","hsla","hue","saturation","lightness","hueToRgb","q","hslaToRgba","mixLinearColor","fromExpo","toExpo","colorTypes","getColorType","find","notAnimatable","color","mixColor","fromColorType","toColorType","fromColor","toColor","blended","colorToken","numberToken","analyse","numColors","colors","map","numbers","tokenised","createTransformer","numValues","output","convertNumbersToZero","complex","getAnimatableNone","parsed","transformer","isNum","getMixer","mixComplex","mixArray","blendValue","fromThis","mixObject","numNumbers","numRGB","numHSL","template","originStats","targetStats","mixNumber","createMixers","ease","customMixer","mixers","mixerFactory","numMixers","mixer","easingFunction","interpolate","input","isClamp","inputLength","reverse","interpolator","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","reverseEasing","easing","mirrorEasing","createBackIn","power","BOUNCE_FIRST_THRESHOLD","BOUNCE_SECOND_THRESHOLD","linear","easeIn","easeOut","easeInOut","circIn","acos","circOut","circInOut","backIn","backOut","backInOut","anticipate","backEasing","createAnticipate","ca","cb","cc","bounceOut","p2","bounceIn","defaultEasing","splice","keyframes","times","o","convertOffsetToTimes","_value","defaultOffset","createInterpolator","types","timeConstant","modifyTarget","amplitude","ideal","defaultTimestep","getCurrentTime","performance","now","Date","onNextFrame","setTimeout","useDefaultElapsed","runNextFrame","isProcessing","timestamp","stepsOrder","steps","acc","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","add","cancel","index","process","frameData","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","getFrameData","loopElapsed","elapsed","delay","framesync","update","passTimestamp","stop","autoplay","driver","repeat","repeatMax","repeatType","repeatDelay","onPlay","onStop","onComplete","onRepeat","onUpdate","driverControls","latest","interpolateFromNumber","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","detectAnimationFromOptions","reverseElapsed","hasRepeatDelayElapsed","velocityPerSecond","frameDuration","secondsToMilliseconds","seconds","a1","a2","calcBezier","getSlope","kSampleStepSize","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","Float32Array","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","easingLookup","bounceInOut","easingDefinitionToFunction","isAnimatable","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","backgroundColor","maxDefaults","applyDefaultFilter","slice","defaultValue","functionRegex","filter","functions","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","defaultValueType","instantAnimationState","convertTransitionToAnimationOptions","yoyo","flip","loop","isEasingArray","getPopmotionAnimationOptions","valueKey","transitionFactory","hydrateKeyframes","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","getAnimation","valueTransition","getValueTransition","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","bounceStiffness","bounceDamping","currentAnimation","isOutOfBounds","boundaryNearest","startAnimation","startSpring","boundary","heading","checkBoundary","inertia","finalTarget","potentialUnitType","delayTimer","controls","getDelayFromTransition","clearTimeout","isZeroValueString","addUniqueItem","arr","item","removeItem","SubscriptionManager","subscriptions","_this","notify","numSubscriptions","getSize","clear","MotionValue","version","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","postRender","scheduleVelocityCheck","velocityCheck","hasAnimated","onChange","subscription","clearListeners","onRenderRequest","attach","passiveEffect","getPrevious","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","motionValue","testValueType","dimensionValueTypes","findDimensionValueType","valueTypes","findValueType","setMotionValue","hasValue","getValue","addValue","setTarget","makeTargetAnimatable","getOriginFromTransition","animateVariant","variant","getDefaultTransition","transitionOverride","animateTarget","getChildAnimations","variantChildren","forwardDelay","animations","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","notifyAnimationComplete","animateChildren","first","last","_e","_f","animationTypeState","getState","shouldBlockAnimation","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","variantPriorityOrder","Animate","Drag","Exit","reversePriorityOrder","numAnimationTypes","animateList","notifyAnimationStart","resolvedDefinition","animateVisualElement","createAnimationState","createTypeState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","isAnimated","setAnimateFunction","makeAnimator","subscribe","safeToRemove","isPoint","isPoint3D","distance1D","xDelta","yDelta","zDelta","PanSession","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","subtractPoint","lastDevicePoint","startDevicePoint","timestampedPoint","lastPoint","time","calcLength","axis","isNear","maxDistance","calcAxisDelta","originPoint","translate","calcBoxDelta","calcRelativeAxis","relative","calcRelativeAxisPosition","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","eachAxis","convertBoundingBoxToBox","isIdentityScale","hasScale","hasTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","translateAxis","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","transformBox","measureViewportBox","topLeft","bottomRight","transformBoxPoints","elementDragControls","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","panSession","dragPropagation","onDragStart","resolveConstraints","isAnimationBlocked","getAxisMotionValue","measuredAxis","actual","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","getTransformPagePoint","onDragEnd","_point","shouldDrag","axisValue","prevConstraints","resolveRefConstraints","layoutBox","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","dragKey","externalMotionValue","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","updateScroll","updateLayout","addListeners","stopPointerListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","groupDragControls","dragControls","names","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","removeFromVariantTree","isMounted","lifecycles","managers","propSubscriptions","clearAllListeners","manager","updatePropListeners","on","propListener","args","_i","createLifecycles","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","notifyUpdate","bindToMotionValue","removeOnChange","latestValue","removeOnRenderRequest","initialMotionValues","depth","isVisible","newInstance","addVariantChild","remove","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","setVisibility","visibility","canMutate","removeValue","readValue","setBaseTarget","newProps","nextValue","prevValue","existingValue","updateMotionValuesFromProps","getVariant","startAtParent","context_1","numVariantProps","variantProps","cssVariableRegex","getVariableValue","exec","parseCSSVariable","token","getComputedStyle","getPropertyValue","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","positionalValues","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY_1","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","targetBbox","convertChangedValueTypes","scrollTo","unitConversion","hasPositionalKey","parseDomVariant","Element","resolveCSSVariables","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","getOrigin","newValueKeys","numNewValues","targetValue","checkTargetForNewValues","htmlVisualElement","svgVisualElement","getAttribute","_element","pixelsToPercent","pixels","correctBorderRadius","correct","node","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","cssVariables","shadow","xScale","yScale","averageScale","i_1","cssVariable","MeasureLayoutWithContext","componentDidMount","correctors","layoutGroup","switchLayoutGroup","defaultScaleCorrectors","group","didUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","deregister","applyTo","boxShadow","layoutFeatures","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","isDirty","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","ProjectionNode","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","animationProgress","sharedNodes","path","registerPotentialNode","notifyListeners","subscriptionManager","hasListeners","SVGElement","tagName","unblockTimeout_1","resizeUnblockUpdate_1","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","mountNodeEarly","resetTransformStyle","notifyLayoutUpdate","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","measure","removeTransform","removeElementScroll","roundBox","prevLayout","layoutCorrected","notifyLayoutMeasure","isScrollRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","attemptToResolveRelativeTarget","pendingAnimation","getLead","treePath","isSharedTransition","treeLength","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","completeAnimation","applyTransformsToTarget","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","styles","pointerEvents","emptyStyles","valuesToRender","_h","corrected","num","resetTree","layout_1","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","searchNode","querySelector","roundAxis","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","documentNode","position","featureBundle","motion","baseConfig","isBrowser","prefersReducedMotion","hasDetected","useReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","useState","useReducedMotionConfig","reducedMotionPreference"],"sourceRoot":""}