{"version":3,"file":"static/chunks/ebaf4c27.82e3736643f0b462.js","mappings":"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","sources":["webpack://_N_E/./node_modules/framer-motion/dist/framer-motion.cjs.js","webpack://_N_E/<anon>"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar React = require('react');\nvar heyListen = require('hey-listen');\nvar styleValueTypes = require('style-value-types');\nvar popmotion = require('popmotion');\nvar sync = require('framesync');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        Object.keys(e).forEach(function (k) {\n            if (k !== 'default') {\n                var d = Object.getOwnPropertyDescriptor(e, k);\n                Object.defineProperty(n, k, d.get ? d : {\n                    enumerable: true,\n                    get: function () {\n                        return e[k];\n                    }\n                });\n            }\n        });\n    }\n    n['default'] = e;\n    return Object.freeze(n);\n}\n\nvar React__namespace = /*#__PURE__*/_interopNamespace(React);\nvar React__default = /*#__PURE__*/_interopDefaultLegacy(React);\nvar sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);\n\nvar createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\n        \"layout\",\n        \"layoutId\",\n        \"drag\",\n        \"_layoutResetTransform\",\n    ]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\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    layoutAnimation: createDefinition([\"layout\", \"layoutId\"]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        var Component = features[key];\n        if (Component !== null)\n            featureDefinitions[key].Component = Component;\n    }\n}\n\nvar LazyContext = React.createContext({ strict: false });\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 = React.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 (process.env.NODE_ENV !== \"production\" &&\n        preloadedFeatures &&\n        lazyContext.strict) {\n        heyListen.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__namespace.createElement(Component, tslib.__assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\n/**\n * @public\n */\nvar MotionConfigContext = React.createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n});\n\nvar MotionContext = React.createContext({});\nfunction useVisualElementContext() {\n    return React.useContext(MotionContext).visualElement;\n}\n\n/**\n * @public\n */\nvar PresenceContext = React.createContext(null);\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 = React.useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\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 = React.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 useOpaqueId when released in React\n    var id = useUniqueId();\n    React.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(React.useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useUniqueId = function () { return useConstant(incrementId); };\n\n/**\n * @internal\n */\nvar LayoutGroupContext = React.createContext(null);\n\nvar isBrowser = typeof window !== \"undefined\";\n\nvar useIsomorphicLayoutEffect = isBrowser ? React.useLayoutEffect : React.useEffect;\n\nfunction useLayoutId(_a) {\n    var layoutId = _a.layoutId;\n    var layoutGroupId = React.useContext(LayoutGroupContext);\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var config = React.useContext(MotionConfigContext);\n    var lazyContext = React.useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = React.useContext(PresenceContext);\n    var layoutId = useLayoutId(props);\n    var visualElementRef = React.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: tslib.__assign(tslib.__assign({}, props), { layoutId: layoutId }),\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        if (!visualElement)\n            return;\n        visualElement.setProps(tslib.__assign(tslib.__assign(tslib.__assign({}, config), props), { layoutId: layoutId }));\n        visualElement.isPresent = isPresent(presenceContext);\n        visualElement.isPresenceRoot =\n            !parent || parent.presenceId !== (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id);\n        /**\n         * Fire a render to ensure the latest state is reflected on-screen.\n         */\n        visualElement.syncRender();\n    });\n    React.useEffect(function () {\n        var _a;\n        if (!visualElement)\n            return;\n        /**\n         * In a future refactor we can replace the features-as-components and\n         * have this loop through them all firing \"effect\" listeners\n         */\n        (_a = 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\nfunction isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\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 React.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\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$1(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    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    return typeof definition === \"function\"\n        ? definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity)\n        : 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$1(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\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\nfunction useCreateMotionContext(props, isStatic) {\n    var _a = getCurrentTreeVariants(props, React.useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return React.useMemo(function () { return ({ initial: initial, animate: animate }); }, \n    /**\n     * Only break memoisation in static mode\n     */\n    isStatic\n        ? [\n            variantLabelsAsDependency(initial),\n            variantLabelsAsDependency(animate),\n        ]\n        : []);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\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 *\n * @internal\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\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 isStatic = React.useContext(MotionConfigContext).isStatic;\n        var features = null;\n        /**\n         * Create the tree context. This is memoized and will only trigger renders\n         * when the current tree variant changes in static mode.\n         */\n        var context = useCreateMotionContext(props, isStatic);\n        /**\n         *\n         */\n        var visualState = useVisualState(props, isStatic);\n        if (!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, props, createVisualElement);\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             * TODO: The intention is to move these away from a React-centric to a\n             * VisualElement-centric lifecycle scheme.\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__namespace.createElement(React__namespace.Fragment, null,\n            React__namespace.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic)),\n            features));\n    }\n    return React.forwardRef(MotionComponent);\n}\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    /**\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\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\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\nvar valueScaleCorrection = {};\n/**\n * @internal\n */\nfunction addScaleCorrection(correctors) {\n    for (var key in correctors) {\n        valueScaleCorrection[key] = correctors[key];\n    }\n}\n\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\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!valueScaleCorrection[key] || key === \"opacity\")));\n}\n\nvar isMotionValue = function (value) {\n    return value !== null && typeof value === \"object\" && value.getVelocity;\n};\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 += (translateAlias[key] || key) + \"(\" + 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 originX + \" \" + originY + \" \" + originZ;\n}\n\n/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable$1(key) {\n    return key.startsWith(\"--\");\n}\n\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\nvar int = tslib.__assign(tslib.__assign({}, styleValueTypes.number), { transform: Math.round });\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: styleValueTypes.px,\n    borderTopWidth: styleValueTypes.px,\n    borderRightWidth: styleValueTypes.px,\n    borderBottomWidth: styleValueTypes.px,\n    borderLeftWidth: styleValueTypes.px,\n    borderRadius: styleValueTypes.px,\n    radius: styleValueTypes.px,\n    borderTopLeftRadius: styleValueTypes.px,\n    borderTopRightRadius: styleValueTypes.px,\n    borderBottomRightRadius: styleValueTypes.px,\n    borderBottomLeftRadius: styleValueTypes.px,\n    // Positioning props\n    width: styleValueTypes.px,\n    maxWidth: styleValueTypes.px,\n    height: styleValueTypes.px,\n    maxHeight: styleValueTypes.px,\n    size: styleValueTypes.px,\n    top: styleValueTypes.px,\n    right: styleValueTypes.px,\n    bottom: styleValueTypes.px,\n    left: styleValueTypes.px,\n    // Spacing props\n    padding: styleValueTypes.px,\n    paddingTop: styleValueTypes.px,\n    paddingRight: styleValueTypes.px,\n    paddingBottom: styleValueTypes.px,\n    paddingLeft: styleValueTypes.px,\n    margin: styleValueTypes.px,\n    marginTop: styleValueTypes.px,\n    marginRight: styleValueTypes.px,\n    marginBottom: styleValueTypes.px,\n    marginLeft: styleValueTypes.px,\n    // Transform props\n    rotate: styleValueTypes.degrees,\n    rotateX: styleValueTypes.degrees,\n    rotateY: styleValueTypes.degrees,\n    rotateZ: styleValueTypes.degrees,\n    scale: styleValueTypes.scale,\n    scaleX: styleValueTypes.scale,\n    scaleY: styleValueTypes.scale,\n    scaleZ: styleValueTypes.scale,\n    skew: styleValueTypes.degrees,\n    skewX: styleValueTypes.degrees,\n    skewY: styleValueTypes.degrees,\n    distance: styleValueTypes.px,\n    translateX: styleValueTypes.px,\n    translateY: styleValueTypes.px,\n    translateZ: styleValueTypes.px,\n    x: styleValueTypes.px,\n    y: styleValueTypes.px,\n    z: styleValueTypes.px,\n    perspective: styleValueTypes.px,\n    transformPerspective: styleValueTypes.px,\n    opacity: styleValueTypes.alpha,\n    originX: styleValueTypes.progressPercentage,\n    originY: styleValueTypes.progressPercentage,\n    originZ: styleValueTypes.px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: styleValueTypes.alpha,\n    strokeOpacity: styleValueTypes.alpha,\n    numOctaves: int,\n};\n\nfunction buildHTMLStyles(state, latestValues, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin) {\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$1(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            /**\n             * If layout projection is on, and we need to perform scale correction for this\n             * value type, perform it.\n             */\n            if ((projection === null || projection === void 0 ? void 0 : projection.isHydrated) &&\n                (layoutState === null || layoutState === void 0 ? void 0 : layoutState.isHydrated) &&\n                valueScaleCorrection[key]) {\n                var correctedValue = valueScaleCorrection[key].process(value, layoutState, projection);\n                /**\n                 * Scale-correctable values can define a number of other values to break\n                 * down into. For instance borderRadius needs applying to borderBottomLeftRadius etc\n                 */\n                var applyTo = valueScaleCorrection[key].applyTo;\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        style[applyTo[i]] = correctedValue;\n                    }\n                }\n                else {\n                    style[key] = correctedValue;\n                }\n            }\n            else {\n                style[key] = valueAsType;\n            }\n        }\n    }\n    if (layoutState &&\n        projection &&\n        buildProjectionTransform &&\n        buildProjectionTransformOrigin) {\n        style.transform = buildProjectionTransform(layoutState.deltaFinal, layoutState.treeScale, hasTransform ? transform : undefined);\n        if (transformTemplate) {\n            style.transform = transformTemplate(transform, style.transform);\n        }\n        style.transformOrigin = buildProjectionTransformOrigin(layoutState);\n    }\n    else {\n        if (hasTransform) {\n            style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n        }\n        if (hasTransformOrigin) {\n            style.transformOrigin = buildTransformOrigin(transformOrigin);\n        }\n    }\n}\n\nvar createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\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 React.useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, undefined, undefined, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return tslib.__assign(tslib.__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)) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect = style.WebkitUserSelect = style.WebkitTouchCallout =\n            \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\" + (props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\n/**\n * A list of all valid MotionProps.\n *\n * @internalremarks\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    \"_layoutResetTransform\",\n    \"onLayoutAnimationComplete\",\n    \"onViewportBoxUpdate\",\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    \"_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]);\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\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\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    var emotionIsPropValid_1 = require(\"@emotion/is-prop-valid\").default;\n    shouldForward = function (key) {\n        // Handle events explicitly as Emotion validates them all as true\n        if (key.startsWith(\"on\")) {\n            return !isValidMotionProp(key);\n        }\n        else {\n            return emotionIsPropValid_1(key);\n        }\n    };\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            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nfunction calcOrigin$1(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : styleValueTypes.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$1(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin$1(originY, dimensions.y, dimensions.height);\n    return pxOriginX + \" \" + pxOriginY;\n}\n\n// Convert a progress 0-1 to a pixels value based on the provided length\nvar progressToPixels = function (progress, length) {\n    return styleValueTypes.px.transform(progress * length);\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, totalLength, 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    // 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] = progressToPixels(-offset, totalLength);\n    // Build the dash array\n    var pathLength = progressToPixels(length, totalLength);\n    var pathSpacing = progressToPixels(spacing, totalLength);\n    attrs[keys.array] = pathLength + \" \" + pathSpacing;\n}\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin) {\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 = tslib.__rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions, totalPathLength = state.totalPathLength;\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 measured\n    if (totalPathLength !== undefined && pathLength !== undefined) {\n        buildSVGPath(attrs, totalPathLength, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nvar createSvgRenderState = function () { return (tslib.__assign(tslib.__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = React.useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, undefined, undefined, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return tslib.__assign(tslib.__assign({}, state.attrs), { style: tslib.__assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = tslib.__assign(tslib.__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, 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 = tslib.__assign(tslib.__assign(tslib.__assign({}, filteredProps), visualProps), { ref: ref });\n        return React.createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nvar 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\nfunction renderHTML(element, _a) {\n    var style = _a.style, vars = _a.vars;\n    // Directly assign style into the Element's style prop. In tests Object.assign is the\n    // fastest way to assign styles.\n    Object.assign(element.style, style);\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\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]);\n\nfunction renderSVG(element, renderState) {\n    renderHTML(element, renderState);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nfunction scrapeMotionValuesFromProps$1(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\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\nfunction isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nvar isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\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\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 *\n * @internal\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\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) { return function (props, isStatic) {\n    var context = React.useContext(MotionContext);\n    var presenceContext = React.useContext(PresenceContext);\n    return isStatic\n        ? makeState(config, props, context, presenceContext)\n        : useConstant(function () { return makeState(config, props, context, presenceContext); });\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 variantToSet = blockInitialAnimation || initial === false ? 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 = tslib.__rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target)\n                values[key] = target[key];\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\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            if (isPath(instance)) {\n                renderState.totalPathLength = instance.getTotalLength();\n            }\n            buildSVGAttrs(renderState, latestValues, undefined, undefined, { enableHardwareAcceleration: false }, props.transformTemplate);\n            // TODO: Replace with direct assignment\n            renderSVG(instance, renderState);\n        },\n    }),\n};\nfunction isPath(element) {\n    return element.tagName === \"path\";\n}\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return tslib.__assign(tslib.__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement,\n        Component: Component });\n}\n\nvar 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[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nfunction addDomEvent(target, eventName, handler, options) {\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler, options); };\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    React.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\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\nfunction 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\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}\nfunction getViewportPointFromEvent(event) {\n    return extractEventInfo(event, \"client\");\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\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\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\nfunction 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\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\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);\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined);\n}\n\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\nfunction useUnmountEffect(callback) {\n    return React.useEffect(function () { return function () { return callback(); }; }, []);\n}\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 = React.useRef(false);\n    var cancelPointerEndListeners = React.useRef(null);\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 = popmotion.pipe(addPointerEvent(window, \"pointerup\", onPointerUp), addPointerEvent(window, \"pointercancel\", onPointerCancel));\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined);\n    useUnmountEffect(removePointerEndListener);\n}\n\nvar makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nvar gestureAnimations = {\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nfunction 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\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\nvar easingLookup = {\n    linear: popmotion.linear,\n    easeIn: popmotion.easeIn,\n    easeInOut: popmotion.easeInOut,\n    easeOut: popmotion.easeOut,\n    circIn: popmotion.circIn,\n    circInOut: popmotion.circInOut,\n    circOut: popmotion.circOut,\n    backIn: popmotion.backIn,\n    backInOut: popmotion.backInOut,\n    backOut: popmotion.backOut,\n    anticipate: popmotion.anticipate,\n    bounceIn: popmotion.bounceIn,\n    bounceInOut: popmotion.bounceInOut,\n    bounceOut: popmotion.bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        heyListen.invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = tslib.__read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return popmotion.cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        heyListen.invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\" + 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\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        styleValueTypes.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\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\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    restDelta: 0.01,\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 tslib.__assign({ to: to }, transitionFactory(to));\n};\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = tslib.__assign(tslib.__assign({}, numberValueTypes), { \n    // Color props\n    color: styleValueTypes.color, backgroundColor: styleValueTypes.color, outlineColor: styleValueTypes.color, fill: styleValueTypes.color, stroke: styleValueTypes.color, \n    // Border props\n    borderColor: styleValueTypes.color, borderTopColor: styleValueTypes.color, borderRightColor: styleValueTypes.color, borderBottomColor: styleValueTypes.color, borderLeftColor: styleValueTypes.color, filter: styleValueTypes.filter, WebkitFilter: styleValueTypes.filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== styleValueTypes.filter)\n        defaultValueType = styleValueTypes.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\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 = tslib.__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 = tslib.__rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = tslib.__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        heyListen.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;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = tslib.__spreadArray([], tslib.__read(options.to));\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 = tslib.__assign(tslib.__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return tslib.__assign(tslib.__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    heyListen.warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \" + key + \" from \\\"\" + origin + \"\\\" to \\\"\" + target + \"\\\". \" + origin + \" is not an animatable value - to enable this animation set \" + origin + \" to a value animatable to \" + 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            ? popmotion.inertia(tslib.__assign(tslib.__assign({}, options), valueTransition))\n            : popmotion.animate(tslib.__assign(tslib.__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;\n        value.set(target);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.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 *\n * @internal\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\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 = 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\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\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\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\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         * 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 = sync.getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync__default['default'].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__default['default'].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     * @library\n     *\n     * ```jsx\n     * function 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 <Frame x={x} />\n     * }\n     * ```\n     *\n     * @motion\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     * @internalremarks\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                popmotion.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}());\n/**\n * @internal\n */\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\n/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\n/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [styleValueTypes.number, styleValueTypes.px, styleValueTypes.percent, styleValueTypes.degrees, styleValueTypes.vw, styleValueTypes.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\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(dimensionValueTypes)), [styleValueTypes.color, styleValueTypes.complex]);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\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\n        ? visualElement.makeTargetAnimatable(resolved, false)\n        : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = tslib.__rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = tslib.__assign(tslib.__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 = tslib.__spreadArray([], tslib.__read(variantLabels)).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\" && isNumericalString(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) && styleValueTypes.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\n/**\n * @internal\n */\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart();\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 = tslib.__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 = tslib.__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 animation = startAnimation(key, value, valueTarget, tslib.__assign({ delay: delay }, transition));\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, tslib.__assign(tslib.__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\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Focus,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = tslib.__spreadArray([], tslib.__read(variantPriorityOrder)).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 = tslib.__rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = tslib.__assign(tslib.__assign(tslib.__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 = tslib.__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 shouldAnimateType = variantsHaveChanged(typeState.prevProp, prop) ||\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 = tslib.__assign(tslib.__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)) {\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 = tslib.__assign(tslib.__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, tslib.__spreadArray([], tslib.__read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: tslib.__assign({ type: type }, options),\n                }); }))));\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 = tslib.__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        return animateChanges(options, type);\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction variantsHaveChanged(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.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\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            React.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 = tslib.__read(usePresence(), 2), isPresent = _a[0], onExitComplete = _a[1];\n        var presenceContext = React.useContext(PresenceContext);\n        React.useEffect(function () {\n            var _a, _b;\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(onExitComplete));\n        }, [isPresent]);\n    }),\n};\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 = popmotion.distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = sync.getFrameData().timestamp;\n            _this.history.push(tslib.__assign(tslib.__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__default['default'].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 = sync.getFrameData().timestamp;\n        this.history = [tslib.__assign(tslib.__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = popmotion.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        sync.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\nfunction noop(any) {\n    return any;\n}\n\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 convertBoundingBoxToAxisBox(_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 convertAxisBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return {\n        top: y.min,\n        bottom: y.max,\n        left: x.min,\n        right: x.max,\n    };\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 transformBoundingBox(_a, transformPoint) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    if (transformPoint === void 0) { transformPoint = noop; }\n    var topLeft = transformPoint({ x: left, y: top });\n    var bottomRight = transformPoint({ x: right, y: bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n/**\n * Create an empty axis box of zero size\n */\nfunction axisBox() {\n    return { x: { min: 0, max: 1 }, y: { min: 0, max: 1 } };\n}\nfunction copyAxisBox(box) {\n    return {\n        x: tslib.__assign({}, box.x),\n        y: tslib.__assign({}, box.y),\n    };\n}\n/**\n * Create an empty box delta\n */\nvar zeroDelta = {\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n};\nfunction delta() {\n    return {\n        x: tslib.__assign({}, zeroDelta),\n        y: tslib.__assign({}, zeroDelta),\n    };\n}\n\n// Call a handler once for each axis\nfunction eachAxis(handler) {\n    return [handler(\"x\"), handler(\"y\")];\n}\n\nvar clampProgress = function (v) { return popmotion.clamp(0, 1, v); };\n/**\n * Returns true if the provided value is within maxDistance of the provided target\n */\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return popmotion.distance(value, target) < maxDistance;\n}\nfunction calcLength(axis) {\n    return axis.max - axis.min;\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 = popmotion.progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = popmotion.progress(source.min, source.max - targetLength, target.min);\n    }\n    return clampProgress(origin);\n}\n/**\n * Update the AxisDelta with a transform that projects source into target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = popmotion.mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001))\n        delta.scale = 1;\n    delta.translate =\n        popmotion.mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate))\n        delta.translate = 0;\n}\n/**\n * Update the BoxDelta with a transform that projects the source into the target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateBoxDelta(delta, source, target, origin) {\n    updateAxisDelta(delta.x, source.x, target.x, defaultOrigin(origin.originX));\n    updateAxisDelta(delta.y, source.y, target.y, defaultOrigin(origin.originY));\n}\n/**\n * Currently this only accepts numerical origins, measured as 0-1, but could\n * accept pixel values by comparing to the target axis.\n */\nfunction defaultOrigin(origin) {\n    return typeof origin === \"number\" ? origin : 0.5;\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(projection, parentProjection) {\n    calcRelativeAxis(projection.target.x, projection.relativeTarget.x, parentProjection.target.x);\n    calcRelativeAxis(projection.target.y, projection.relativeTarget.y, parentProjection.target.y);\n}\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 ? popmotion.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 ? popmotion.mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculates a min projection point based on a pointer, pointer progress\n * within the drag target, and constraints.\n *\n * For instance if an element was 100px width, we were dragging from 0.25\n * along this axis, the pointer is at 200px, and there were no constraints,\n * we would calculate a min projection point of 175px.\n */\nfunction calcConstrainedMinPoint(point, length, progress, constraints, elastic) {\n    // Calculate a min point for this axis and apply it to the current pointer\n    var min = point - length * progress;\n    return constraints ? applyConstraints(min, constraints, elastic) : min;\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 = tslib.__read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return {\n        min: layoutAxis.min + min,\n        max: layoutAxis.min + max,\n    };\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 the an axis position based on two axes and a progress value.\n */\nfunction calcPositionFromProgress(axis, constraints, progress) {\n    var axisLength = axis.max - axis.min;\n    var min = popmotion.mix(constraints.min, constraints.max - axisLength, progress);\n    return { min: min, max: min + axisLength };\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 === 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\n/**\n * Measure and return the element bounding box.\n *\n * We convert the box into an AxisBox2D to make it easier to work with each axis\n * individually and programmatically.\n *\n * This function optionally accepts a transformPagePoint function which allows us to compensate\n * for, for instance, measuring the element within a scaled plane like a Framer devivce preview component.\n */\nfunction getBoundingBox(element, transformPagePoint) {\n    var box = element.getBoundingClientRect();\n    return convertBoundingBoxToAxisBox(transformBoundingBox(box, transformPagePoint));\n}\n\nvar compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nfunction isProjecting(visualElement) {\n    var isEnabled = visualElement.projection.isEnabled;\n    return isEnabled || visualElement.shouldResetTransform();\n}\nfunction collectProjectingAncestors(visualElement, ancestors) {\n    if (ancestors === void 0) { ancestors = []; }\n    var parent = visualElement.parent;\n    if (parent)\n        collectProjectingAncestors(parent, ancestors);\n    if (isProjecting(visualElement))\n        ancestors.push(visualElement);\n    return ancestors;\n}\nfunction collectProjectingChildren(visualElement) {\n    var children = [];\n    var addChild = function (child) {\n        if (isProjecting(child))\n            children.push(child);\n        child.children.forEach(addChild);\n    };\n    visualElement.children.forEach(addChild);\n    return children.sort(compareByDepth);\n}\n/**\n * Update the layoutState by measuring the DOM layout. This\n * should be called after resetting any layout-affecting transforms.\n */\nfunction updateLayoutMeasurement(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    var layoutState = visualElement.getLayoutState();\n    visualElement.notifyBeforeLayoutMeasure(layoutState.layout);\n    layoutState.isHydrated = true;\n    layoutState.layout = visualElement.measureViewportBox();\n    layoutState.layoutCorrected = copyAxisBox(layoutState.layout);\n    visualElement.notifyLayoutMeasure(layoutState.layout, visualElement.prevViewportBox || layoutState.layout);\n    sync__default['default'].update(function () { return visualElement.rebaseProjectionTarget(); });\n}\n/**\n * Record the viewport box as it was before an expected mutation/re-render\n */\nfunction snapshotViewportBox(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    visualElement.prevViewportBox = visualElement.measureViewportBox(false);\n    /**\n     * Update targetBox to match the prevViewportBox. This is just to ensure\n     * that targetBox is affected by scroll in the same way as the measured box\n     */\n    visualElement.rebaseProjectionTarget(false, visualElement.prevViewportBox);\n}\n\nfunction tweenAxis(target, prev, next, p) {\n    target.min = popmotion.mix(prev.min, next.min, p);\n    target.max = popmotion.mix(prev.max, next.max, p);\n}\nfunction calcRelativeOffsetAxis(parent, child) {\n    return {\n        min: child.min - parent.min,\n        max: child.max - parent.min,\n    };\n}\nfunction calcRelativeOffset(parent, child) {\n    return {\n        x: calcRelativeOffsetAxis(parent.x, child.x),\n        y: calcRelativeOffsetAxis(parent.y, child.y),\n    };\n}\nfunction checkIfParentHasChanged(prev, next) {\n    var prevId = prev.getLayoutId();\n    var nextId = next.getLayoutId();\n    return prevId !== nextId || (nextId === undefined && prev !== next);\n}\n\nfunction isDraggable(visualElement) {\n    var _a = visualElement.getProps(), drag = _a.drag, _dragX = _a._dragX;\n    return drag && !_dragX;\n}\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction resetAxis(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 resetBox(box, originBox) {\n    resetAxis(box.x, originBox.x);\n    resetAxis(box.y, originBox.y);\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 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 applyAxisTransforms(final, axis, transforms, _a) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    // Copy the current axis to the final axis before mutation\n    final.min = axis.min;\n    final.max = axis.max;\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = popmotion.mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(final, 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 applyBoxTransforms(finalBox, box, transforms) {\n    applyAxisTransforms(finalBox.x, box.x, transforms, xKeys);\n    applyAxisTransforms(finalBox.y, box.y, transforms, yKeys);\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) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    var originPoint = popmotion.mix(axis.min, axis.max, origin) - 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) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale);\n}\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) {\n    removeAxisTransforms(box.x, transforms, xKeys);\n    removeAxisTransforms(box.y, transforms, yKeys);\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) {\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.getLayoutState().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        // If this is a draggable ancestor, also incorporate the node's transform to the layout box\n        if (isDraggable(node)) {\n            applyBoxTransforms(box, box, node.getLatestValues());\n        }\n    }\n}\n\n/**\n * Returns a boolean stating whether or not we converted the projection\n * to relative projection.\n */\nfunction convertToRelativeProjection(visualElement, isLayoutDrag) {\n    if (isLayoutDrag === void 0) { isLayoutDrag = true; }\n    var projectionParent = visualElement.getProjectionParent();\n    if (!projectionParent)\n        return false;\n    var offset;\n    if (isLayoutDrag) {\n        offset = calcRelativeOffset(projectionParent.projection.target, visualElement.projection.target);\n        removeBoxTransforms(offset, projectionParent.getLatestValues());\n    }\n    else {\n        offset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n    }\n    eachAxis(function (axis) {\n        return visualElement.setProjectionTargetAxis(axis, offset[axis].min, offset[axis].max, true);\n    });\n    return true;\n}\n\nvar unresolvedJobs = new Set();\nfunction pushJob(stack, job, pointer) {\n    if (!stack[pointer])\n        stack[pointer] = [];\n    stack[pointer].push(job);\n}\nfunction batchLayout(callback) {\n    unresolvedJobs.add(callback);\n    return function () { return unresolvedJobs.delete(callback); };\n}\nfunction flushLayout() {\n    if (!unresolvedJobs.size)\n        return;\n    var pointer = 0;\n    var reads = [[]];\n    var writes = [];\n    var setRead = function (job) { return pushJob(reads, job, pointer); };\n    var setWrite = function (job) {\n        pushJob(writes, job, pointer);\n        pointer++;\n    };\n    /**\n     * Resolve jobs into their array stacks\n     */\n    unresolvedJobs.forEach(function (callback) {\n        callback(setRead, setWrite);\n        pointer = 0;\n    });\n    unresolvedJobs.clear();\n    /**\n     * Execute jobs\n     */\n    var numStacks = writes.length;\n    for (var i = 0; i <= numStacks; i++) {\n        reads[i] && reads[i].forEach(executeJob);\n        writes[i] && writes[i].forEach(executeJob);\n    }\n}\nvar executeJob = function (job) { return job(); };\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\nvar lastPointerEvent;\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(_a) {\n        var visualElement = _a.visualElement;\n        /**\n         * Track whether we're currently dragging.\n         *\n         * @internal\n         */\n        this.isDragging = false;\n        /**\n         * The current direction of drag, or `null` if both.\n         *\n         * @internal\n         */\n        this.currentDirection = null;\n        /**\n         * The permitted boundaries of travel, in pixels.\n         *\n         * @internal\n         */\n        this.constraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         *\n         * @internal\n         */\n        this.elastic = axisBox();\n        /**\n         * A reference to the host component's latest props.\n         *\n         * @internal\n         */\n        this.props = {};\n        /**\n         * @internal\n         */\n        this.hasMutatedConstraints = false;\n        /**\n         * Track the initial position of the cursor relative to the dragging element\n         * when dragging starts as a value of 0-1 on each axis. We then use this to calculate\n         * an ideal bounding box for the VisualElement renderer to project into every frame.\n         *\n         * @internal\n         */\n        this.cursorProgress = {\n            x: 0.5,\n            y: 0.5,\n        };\n        // When updating _dragX, or _dragY instead of the VisualElement,\n        // persist their values between drag gestures.\n        this.originPoint = {};\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        /**\n         * @internal\n         */\n        this.panSession = null;\n        this.visualElement = visualElement;\n        this.visualElement.enableLayoutProjection();\n        elementDragControls.set(visualElement, this);\n    }\n    /**\n     * Instantiate a PanSession for the drag gesture\n     *\n     * @public\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, cursorProgress = _b.cursorProgress;\n        var onSessionStart = function (event) {\n            var _a;\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopMotion();\n            /**\n             * Save the initial point. We'll use this to calculate the pointer's position rather\n             * than the one we receive when the gesture actually starts. By then, the pointer will\n             * have already moved, and the perception will be of the pointer \"slipping\" across the element\n             */\n            var initialPoint = getViewportPointFromEvent(event).point;\n            (_a = _this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(_this);\n            _this.cancelLayout = batchLayout(function (read, write) {\n                var ancestors = collectProjectingAncestors(_this.visualElement);\n                var children = collectProjectingChildren(_this.visualElement);\n                var tree = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(ancestors)), tslib.__read(children));\n                var hasManuallySetCursorOrigin = false;\n                /**\n                 * Apply a simple lock to the projection target. This ensures no animations\n                 * can run on the projection box while this lock is active.\n                 */\n                _this.isLayoutDrag() && _this.visualElement.lockProjectionTarget();\n                write(function () {\n                    tree.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    updateLayoutMeasurement(_this.visualElement);\n                    children.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    tree.forEach(function (element) { return element.restoreTransform(); });\n                    if (snapToCursor) {\n                        hasManuallySetCursorOrigin = _this.snapToCursor(initialPoint);\n                    }\n                });\n                read(function () {\n                    var isRelativeDrag = Boolean(_this.getAxisMotionValue(\"x\") && !_this.isExternalDrag());\n                    if (!isRelativeDrag) {\n                        _this.visualElement.rebaseProjectionTarget(true, _this.visualElement.measureViewportBox(false));\n                    }\n                    _this.visualElement.scheduleUpdateLayoutProjection();\n                    /**\n                     * When dragging starts, we want to find where the cursor is relative to the bounding box\n                     * of the element. Every frame, we calculate a new bounding box using this relative position\n                     * and let the visualElement renderer figure out how to reproject the element into this bounding\n                     * box.\n                     *\n                     * By doing it this way, rather than applying an x/y transform directly to the element,\n                     * we can ensure the component always visually sticks to the cursor as we'd expect, even\n                     * if the DOM element itself changes layout as a result of React updates the user might\n                     * make based on the drag position.\n                     */\n                    var projection = _this.visualElement.projection;\n                    eachAxis(function (axis) {\n                        if (!hasManuallySetCursorOrigin) {\n                            var _a = projection.target[axis], min = _a.min, max = _a.max;\n                            _this.cursorProgress[axis] = cursorProgress\n                                ? cursorProgress[axis]\n                                : popmotion.progress(min, max, initialPoint[axis]);\n                        }\n                        /**\n                         * If we have external drag MotionValues, record their origin point. On pointermove\n                         * we'll apply the pan gesture offset directly to this value.\n                         */\n                        var axisValue = _this.getAxisMotionValue(axis);\n                        if (axisValue) {\n                            _this.originPoint[axis] = axisValue.get();\n                        }\n                    });\n                });\n                write(function () {\n                    sync.flushSync.update();\n                    sync.flushSync.preRender();\n                    sync.flushSync.render();\n                    sync.flushSync.postRender();\n                });\n                read(function () { return _this.resolveDragConstraints(); });\n            });\n        };\n        var onStart = function (event, info) {\n            var _a, _b, _c;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _d = _this.props, drag = _d.drag, dragPropagation = _d.dragPropagation;\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            flushLayout();\n            // Set current drag status\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            // Fire onDragStart event\n            (_b = (_a = _this.props).onDragStart) === null || _b === void 0 ? void 0 : _b.call(_a, event, info);\n            (_c = _this.visualElement.animationState) === null || _c === void 0 ? void 0 : _c.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            var _a, _b, _c, _d;\n            var _e = _this.props, dragPropagation = _e.dragPropagation, dragDirectionLock = _e.dragDirectionLock;\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                    (_b = (_a = _this.props).onDirectionLock) === null || _b === void 0 ? void 0 : _b.call(_a, _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            // Fire onDrag event\n            (_d = (_c = _this.props).onDrag) === null || _d === void 0 ? void 0 : _d.call(_c, event, info);\n            // Update the last pointer event\n            lastPointerEvent = event;\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        var transformPagePoint = this.props.transformPagePoint;\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: transformPagePoint });\n    };\n    VisualElementDragControls.prototype.resolveDragConstraints = function () {\n        var _this = this;\n        var _a = this.props, dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = this.visualElement.getLayoutState().layoutCorrected;\n        if (dragConstraints) {\n            this.constraints = isRefObject(dragConstraints)\n                ? this.resolveRefConstraints(layout, dragConstraints)\n                : calcRelativeConstraints(layout, dragConstraints);\n        }\n        else {\n            this.constraints = false;\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 (this.constraints && !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function (layoutBox, constraints) {\n        var _a = this.props, onMeasureDragConstraints = _a.onMeasureDragConstraints, transformPagePoint = _a.transformPagePoint;\n        var constraintsElement = constraints.current;\n        heyListen.invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        this.constraintsBox = getBoundingBox(constraintsElement, transformPagePoint);\n        var measuredConstraints = calcViewportConstraints(layoutBox, this.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(convertAxisBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToAxisBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.cancelDrag = function () {\n        var _a, _b;\n        this.visualElement.unlockProjectionTarget();\n        (_a = this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(this);\n        this.isDragging = false;\n        this.panSession && this.panSession.end();\n        this.panSession = null;\n        if (!this.props.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.stop = function (event, info) {\n        var _a, _b, _c;\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = null;\n        var isDragging = this.isDragging;\n        this.cancelDrag();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.animateDragEnd(velocity);\n        (_c = (_b = this.props).onDragEnd) === null || _c === void 0 ? void 0 : _c.call(_b, event, info);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        return eachAxis(function (axis) {\n            var drag = _this.props.drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var box = _this.visualElement.getLayoutState().layout;\n                var length_1 = box[axis].max - box[axis].min;\n                var center = box[axis].min + length_1 / 2;\n                var offset = point[axis] - center;\n                _this.originPoint[axis] = point[axis];\n                axisValue.set(offset);\n            }\n            else {\n                _this.cursorProgress[axis] = 0.5;\n                return true;\n            }\n        }).includes(true);\n    };\n    /**\n     * Update the specified axis with the latest pointer information.\n     */\n    VisualElementDragControls.prototype.updateAxis = function (axis, point, offset) {\n        var drag = this.props.drag;\n        // If we're not dragging this axis, do an early return.\n        if (!shouldDrag(axis, drag, this.currentDirection))\n            return;\n        return this.getAxisMotionValue(axis)\n            ? this.updateAxisMotionValue(axis, offset)\n            : this.updateVisualElementAxis(axis, point);\n    };\n    VisualElementDragControls.prototype.updateAxisMotionValue = function (axis, offset) {\n        var axisValue = this.getAxisMotionValue(axis);\n        if (!offset || !axisValue)\n            return;\n        var nextValue = this.originPoint[axis] + offset[axis];\n        var update = this.constraints\n            ? applyConstraints(nextValue, this.constraints[axis], this.elastic[axis])\n            : nextValue;\n        axisValue.set(update);\n    };\n    VisualElementDragControls.prototype.updateVisualElementAxis = function (axis, point) {\n        var _a;\n        // Get the actual layout bounding box of the element\n        var axisLayout = this.visualElement.getLayoutState().layout[axis];\n        // Calculate its current length. In the future we might want to lerp this to animate\n        // between lengths if the layout changes as we change the DOM\n        var axisLength = axisLayout.max - axisLayout.min;\n        // Get the initial progress that the pointer sat on this axis on gesture start.\n        var axisProgress = this.cursorProgress[axis];\n        // Calculate a new min point based on the latest pointer position, constraints and elastic\n        var min = calcConstrainedMinPoint(point[axis], axisLength, axisProgress, (_a = this.constraints) === null || _a === void 0 ? void 0 : _a[axis], this.elastic[axis]);\n        // Update the axis viewport target with this new min and the length\n        this.visualElement.setProjectionTargetAxis(axis, min, min + axisLength);\n    };\n    VisualElementDragControls.prototype.setProps = function (_a) {\n        var _b = _a.drag, drag = _b === void 0 ? false : _b, _c = _a.dragDirectionLock, dragDirectionLock = _c === void 0 ? false : _c, _d = _a.dragPropagation, dragPropagation = _d === void 0 ? false : _d, _e = _a.dragConstraints, dragConstraints = _e === void 0 ? false : _e, _f = _a.dragElastic, dragElastic = _f === void 0 ? defaultElastic : _f, _g = _a.dragMomentum, dragMomentum = _g === void 0 ? true : _g, remainingProps = tslib.__rest(_a, [\"drag\", \"dragDirectionLock\", \"dragPropagation\", \"dragConstraints\", \"dragElastic\", \"dragMomentum\"]);\n        this.props = tslib.__assign({ drag: drag,\n            dragDirectionLock: dragDirectionLock,\n            dragPropagation: dragPropagation,\n            dragConstraints: dragConstraints,\n            dragElastic: dragElastic,\n            dragMomentum: dragMomentum }, remainingProps);\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     * - If the component will perform layout animations, we output the gesture to the component's\n     *      visual bounding box\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a = this.props, layout = _a.layout, layoutId = _a.layoutId;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        if (this.props[dragKey]) {\n            return this.props[dragKey];\n        }\n        else if (!layout && layoutId === undefined) {\n            return this.visualElement.getValue(axis, 0);\n        }\n    };\n    VisualElementDragControls.prototype.isLayoutDrag = function () {\n        return !this.getAxisMotionValue(\"x\");\n    };\n    VisualElementDragControls.prototype.isExternalDrag = function () {\n        var _a = this.props, _dragX = _a._dragX, _dragY = _a._dragY;\n        return _dragX || _dragY;\n    };\n    VisualElementDragControls.prototype.animateDragEnd = function (velocity) {\n        var _this = this;\n        var _a = this.props, drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition;\n        /**\n         * Everything beyond the drag gesture should be performed with\n         * relative projection so children stay in sync with their parent element.\n         */\n        var isRelative = convertToRelativeProjection(this.visualElement, this.isLayoutDrag() && !this.isExternalDrag());\n        /**\n         * If we had previously resolved constraints relative to the viewport,\n         * we need to also convert those to a relative coordinate space for the animation\n         */\n        var constraints = this.constraints || {};\n        if (isRelative &&\n            Object.keys(constraints).length &&\n            this.isLayoutDrag()) {\n            var projectionParent = this.visualElement.getProjectionParent();\n            if (projectionParent) {\n                var relativeConstraints_1 = calcRelativeOffset(projectionParent.projection.targetFinal, constraints);\n                eachAxis(function (axis) {\n                    var _a = relativeConstraints_1[axis], min = _a.min, max = _a.max;\n                    constraints[axis] = {\n                        min: isNaN(min) ? undefined : min,\n                        max: isNaN(max) ? undefined : max,\n                    };\n                });\n            }\n        }\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            /**\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 = tslib.__assign(tslib.__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness,\n                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.getAxisMotionValue(axis)\n                ? _this.startAxisValueAnimation(axis, inertia)\n                : _this.visualElement.startLayoutAnimation(axis, inertia, isRelative);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(function () {\n            var _a, _b;\n            (_b = (_a = _this.props).onDragTransitionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);\n        });\n    };\n    VisualElementDragControls.prototype.stopMotion = function () {\n        var _this = this;\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            axisValue\n                ? axisValue.stop()\n                : _this.visualElement.stopLayoutAnimation();\n        });\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        if (!axisValue)\n            return;\n        var currentValue = axisValue.get();\n        axisValue.set(currentValue);\n        axisValue.set(currentValue); // Set twice to hard-reset velocity\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.scalePoint = function () {\n        var _this = this;\n        var _a = this.props, drag = _a.drag, dragConstraints = _a.dragConstraints;\n        if (!isRefObject(dragConstraints) || !this.constraintsBox)\n            return;\n        // Stop any current animations as there can be some visual glitching if we resize mid animation\n        this.stopMotion();\n        // Record the relative progress of the targetBox relative to the constraintsBox\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            boxProgress[axis] = calcOrigin(_this.visualElement.projection.target[axis], _this.constraintsBox[axis]);\n        });\n        /**\n         * For each axis, calculate the current progress of the layout axis within the constraints.\n         * Then, using the latest layout and constraints measurements, reposition the new layout axis\n         * proportionally within the constraints.\n         */\n        this.updateConstraints(function () {\n            eachAxis(function (axis) {\n                if (!shouldDrag(axis, drag, null))\n                    return;\n                // Calculate the position of the targetBox relative to the constraintsBox using the\n                // previously calculated progress\n                var _a = calcPositionFromProgress(_this.visualElement.projection.target[axis], _this.constraintsBox[axis], boxProgress[axis]), min = _a.min, max = _a.max;\n                _this.visualElement.setProjectionTargetAxis(axis, min, max);\n            });\n        });\n        /**\n         * If any other draggable components are queuing the same tasks synchronously\n         * this will wait until they've all been scheduled before flushing.\n         */\n        setTimeout(flushLayout, 1);\n    };\n    VisualElementDragControls.prototype.updateConstraints = function (onReady) {\n        var _this = this;\n        this.cancelLayout = batchLayout(function (read, write) {\n            var ancestors = collectProjectingAncestors(_this.visualElement);\n            write(function () {\n                return ancestors.forEach(function (element) { return element.resetTransform(); });\n            });\n            read(function () { return updateLayoutMeasurement(_this.visualElement); });\n            write(function () {\n                return ancestors.forEach(function (element) { return element.restoreTransform(); });\n            });\n            read(function () {\n                _this.resolveDragConstraints();\n            });\n            if (onReady)\n                write(onReady);\n        });\n    };\n    VisualElementDragControls.prototype.mount = function (visualElement) {\n        var _this = this;\n        var element = 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.props, drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\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            _this.scalePoint();\n        });\n        /**\n         * Ensure drag constraints are resolved correctly relative to the dragging element\n         * whenever its layout changes.\n         */\n        var stopLayoutUpdateListener = visualElement.onLayoutUpdate(function () {\n            if (_this.isDragging) {\n                _this.resolveDragConstraints();\n            }\n        });\n        /**\n         * If the previous component with this same layoutId was dragging at the time\n         * it was unmounted, we want to continue the same gesture on this component.\n         */\n        var prevDragCursor = visualElement.prevDragCursor;\n        if (prevDragCursor) {\n            this.start(lastPointerEvent, { cursorProgress: prevDragCursor });\n        }\n        /**\n         * Return a function that will teardown the drag gesture\n         */\n        return function () {\n            stopPointerListener === null || stopPointerListener === void 0 ? void 0 : stopPointerListener();\n            stopResizeListener === null || stopResizeListener === void 0 ? void 0 : stopResizeListener();\n            stopLayoutUpdateListener === null || stopLayoutUpdateListener === void 0 ? void 0 : stopLayoutUpdateListener();\n            _this.cancelDrag();\n        };\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\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 transformPagePoint = React.useContext(MotionConfigContext).transformPagePoint;\n    var dragControls = useConstant(function () {\n        return new VisualElementDragControls({\n            visualElement: visualElement,\n        });\n    });\n    dragControls.setProps(tslib.__assign(tslib.__assign({}, props), { transformPagePoint: transformPagePoint }));\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    React.useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls]);\n    // Mount the drag controls with the visualElement\n    React.useEffect(function () { return dragControls.mount(visualElement); }, []);\n}\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @internalremarks\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 = React.useRef(null);\n    var transformPagePoint = React.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    React.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\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\n/**\n * @public\n */\nvar Presence;\n(function (Presence) {\n    Presence[Presence[\"Entering\"] = 0] = \"Entering\";\n    Presence[Presence[\"Present\"] = 1] = \"Present\";\n    Presence[Presence[\"Exiting\"] = 2] = \"Exiting\";\n})(Presence || (Presence = {}));\n/**\n * @public\n */\nexports.VisibilityAction = void 0;\n(function (VisibilityAction) {\n    VisibilityAction[VisibilityAction[\"Hide\"] = 0] = \"Hide\";\n    VisibilityAction[VisibilityAction[\"Show\"] = 1] = \"Show\";\n})(exports.VisibilityAction || (exports.VisibilityAction = {}));\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 = tslib.__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    heyListen.invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n    var _a = tslib.__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 = tslib.__rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof HTMLElement))\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 = tslib.__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\nfunction pixelsToPercent(pixels, axis) {\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 */\nfunction correctBorderRadius(latest, _layoutState, _a) {\n    var target = _a.target;\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 (styleValueTypes.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, target.x);\n    var y = pixelsToPercent(latest, target.y);\n    return x + \"% \" + y + \"%\";\n}\nvar varToken = \"_$css\";\nfunction correctBoxShadow(latest, _a) {\n    var delta = _a.delta, treeScale = _a.treeScale;\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 = styleValueTypes.complex.parse(latest);\n    // TODO: Doesn't support multiple shadows\n    if (shadow.length > 5)\n        return original;\n    var template = styleValueTypes.complex.createTransformer(latest);\n    var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n    // Calculate the overall context scale\n    var xScale = delta.x.scale * treeScale.x;\n    var yScale = delta.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 = popmotion.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}\nvar borderCorrectionDefinition = {\n    process: correctBorderRadius,\n};\nvar defaultScaleCorrectors = {\n    borderRadius: tslib.__assign(tslib.__assign({}, borderCorrectionDefinition), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: borderCorrectionDefinition,\n    borderTopRightRadius: borderCorrectionDefinition,\n    borderBottomLeftRadius: borderCorrectionDefinition,\n    borderBottomRightRadius: borderCorrectionDefinition,\n    boxShadow: {\n        process: correctBoxShadow,\n    },\n};\n\nvar progressTarget = 1000;\nvar Animate = /** @class */ (function (_super) {\n    tslib.__extends(Animate, _super);\n    function Animate() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /**\n         * A mutable object that tracks the target viewport box\n         * for the current animation frame.\n         */\n        _this.frameTarget = axisBox();\n        /**\n         * The current animation target, we use this to check whether to start\n         * a new animation or continue the existing one.\n         */\n        _this.currentAnimationTarget = axisBox();\n        /**\n         * Track whether we're animating this axis.\n         */\n        _this.isAnimating = {\n            x: false,\n            y: false,\n        };\n        _this.stopAxisAnimation = {\n            x: undefined,\n            y: undefined,\n        };\n        _this.isAnimatingTree = false;\n        _this.animate = function (target, origin, _a) {\n            if (_a === void 0) { _a = {}; }\n            var originBox = _a.originBox, targetBox = _a.targetBox, visibilityAction = _a.visibilityAction, shouldStackAnimate = _a.shouldStackAnimate, onComplete = _a.onComplete, prevParent = _a.prevParent, config = tslib.__rest(_a, [\"originBox\", \"targetBox\", \"visibilityAction\", \"shouldStackAnimate\", \"onComplete\", \"prevParent\"]);\n            var _b = _this.props, visualElement = _b.visualElement, layout = _b.layout;\n            /**\n             * Early return if we've been instructed not to animate this render.\n             */\n            if (shouldStackAnimate === false) {\n                _this.isAnimatingTree = false;\n                return _this.safeToRemove();\n            }\n            /**\n             * Prioritise tree animations\n             */\n            if (_this.isAnimatingTree && shouldStackAnimate !== true) {\n                return;\n            }\n            else if (shouldStackAnimate) {\n                _this.isAnimatingTree = true;\n            }\n            /**\n             * Allow the measured origin (prev bounding box) and target (actual layout) to be\n             * overridden by the provided config.\n             */\n            origin = originBox || origin;\n            target = targetBox || target;\n            /**\n             * If this element has a projecting parent, there's an opportunity to animate\n             * it relatively to that parent rather than relatively to the viewport. This\n             * allows us to add orchestrated animations.\n             */\n            var isRelative = false;\n            var projectionParent = visualElement.getProjectionParent();\n            if (projectionParent) {\n                var prevParentViewportBox = projectionParent.prevViewportBox;\n                var parentLayout = projectionParent.getLayoutState().layout;\n                /**\n                 * If we're being provided a previous parent VisualElement by AnimateSharedLayout\n                 */\n                if (prevParent) {\n                    /**\n                     * If we've been provided an explicit target box it means we're animating back\n                     * to this previous parent. So we can make a relative box by comparing to the previous\n                     * parent's layout\n                     */\n                    if (targetBox) {\n                        parentLayout = prevParent.getLayoutState().layout;\n                    }\n                    /**\n                     * Likewise if we've been provided an explicit origin box it means we're\n                     * animating out from a different element. So we should figure out where that was\n                     * on screen relative to the new parent element.\n                     */\n                    if (originBox &&\n                        !checkIfParentHasChanged(prevParent, projectionParent) &&\n                        prevParent.prevViewportBox) {\n                        prevParentViewportBox = prevParent.prevViewportBox;\n                    }\n                }\n                if (prevParentViewportBox &&\n                    isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox)) {\n                    isRelative = true;\n                    origin = calcRelativeOffset(prevParentViewportBox, origin);\n                    target = calcRelativeOffset(parentLayout, target);\n                }\n            }\n            var boxHasMoved = hasMoved(origin, target);\n            var animations = eachAxis(function (axis) {\n                var _a, _b;\n                /**\n                 * If layout is set to \"position\", we can resize the origin box based on the target\n                 * box and only animate its position.\n                 */\n                if (layout === \"position\") {\n                    var targetLength = target[axis].max - target[axis].min;\n                    origin[axis].max = origin[axis].min + targetLength;\n                }\n                if (visualElement.projection.isTargetLocked) {\n                    return;\n                }\n                else if (visibilityAction !== undefined) {\n                    visualElement.setVisibility(visibilityAction === exports.VisibilityAction.Show);\n                }\n                else if (boxHasMoved) {\n                    // If the box has moved, animate between it's current visual state and its\n                    // final state\n                    return _this.animateAxis(axis, target[axis], origin[axis], tslib.__assign(tslib.__assign({}, config), { isRelative: isRelative }));\n                }\n                else {\n                    (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a);\n                    // If the box has remained in the same place, immediately set the axis target\n                    // to the final desired state\n                    return visualElement.setProjectionTargetAxis(axis, target[axis].min, target[axis].max, isRelative);\n                }\n            });\n            // Force a render to ensure there's no flash of uncorrected bounding box.\n            visualElement.syncRender();\n            /**\n             * If this visualElement isn't present (ie it's been removed from the tree by the user but\n             * kept in by the tree by AnimatePresence) then call safeToRemove when all axis animations\n             * have successfully finished.\n             */\n            return Promise.all(animations).then(function () {\n                _this.isAnimatingTree = false;\n                onComplete && onComplete();\n                visualElement.notifyLayoutAnimationComplete();\n            });\n        };\n        return _this;\n    }\n    Animate.prototype.componentDidMount = function () {\n        var _this = this;\n        var visualElement = this.props.visualElement;\n        visualElement.animateMotionValue = startAnimation;\n        visualElement.enableLayoutProjection();\n        this.unsubLayoutReady = visualElement.onLayoutUpdate(this.animate);\n        visualElement.layoutSafeToRemove = function () { return _this.safeToRemove(); };\n        addScaleCorrection(defaultScaleCorrectors);\n    };\n    Animate.prototype.componentWillUnmount = function () {\n        var _this = this;\n        this.unsubLayoutReady();\n        eachAxis(function (axis) { var _a, _b; return (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a); });\n    };\n    /**\n     * TODO: This manually performs animations on the visualElement's layout progress\n     * values. It'd be preferable to amend the startLayoutAxisAnimation\n     * API to accept more custom animations like this.\n     */\n    Animate.prototype.animateAxis = function (axis, target, origin, _a) {\n        var _this = this;\n        var _b, _c;\n        var _d = _a === void 0 ? {} : _a, transition = _d.transition, isRelative = _d.isRelative;\n        /**\n         * If we're not animating to a new target, don't run this animation\n         */\n        if (this.isAnimating[axis] &&\n            axisIsEqual(target, this.currentAnimationTarget[axis])) {\n            return;\n        }\n        (_c = (_b = this.stopAxisAnimation)[axis]) === null || _c === void 0 ? void 0 : _c.call(_b);\n        this.isAnimating[axis] = true;\n        var visualElement = this.props.visualElement;\n        var frameTarget = this.frameTarget[axis];\n        var layoutProgress = visualElement.getProjectionAnimationProgress()[axis];\n        /**\n         * Set layout progress back to 0. We set it twice to hard-reset any velocity that might\n         * be re-incoporated into a subsequent spring animation.\n         */\n        layoutProgress.clearListeners();\n        layoutProgress.set(0);\n        layoutProgress.set(0);\n        /**\n         * Create an animation function to run once per frame. This will tween the visual bounding box from\n         * origin to target using the latest progress value.\n         */\n        var frame = function () {\n            // Convert the latest layoutProgress, which is a value from 0-1000, into a 0-1 progress\n            var p = layoutProgress.get() / progressTarget;\n            // Tween the axis and update the visualElement with the latest values\n            tweenAxis(frameTarget, origin, target, p);\n            visualElement.setProjectionTargetAxis(axis, frameTarget.min, frameTarget.max, isRelative);\n        };\n        // Synchronously run a frame to ensure there's no flash of the uncorrected bounding box.\n        frame();\n        // Create a function to stop animation on this specific axis\n        var unsubscribeProgress = layoutProgress.onChange(frame);\n        this.stopAxisAnimation[axis] = function () {\n            _this.isAnimating[axis] = false;\n            layoutProgress.stop();\n            unsubscribeProgress();\n        };\n        this.currentAnimationTarget[axis] = target;\n        var layoutTransition = transition ||\n            visualElement.getDefaultTransition() ||\n            defaultLayoutTransition;\n        // Start the animation on this axis\n        var animation = startAnimation(axis === \"x\" ? \"layoutX\" : \"layoutY\", layoutProgress, progressTarget, layoutTransition && getValueTransition(layoutTransition, \"layout\")).then(this.stopAxisAnimation[axis]);\n        return animation;\n    };\n    Animate.prototype.safeToRemove = function () {\n        var _a, _b;\n        (_b = (_a = this.props).safeToRemove) === null || _b === void 0 ? void 0 : _b.call(_a);\n    };\n    Animate.prototype.render = function () {\n        return null;\n    };\n    return Animate;\n}(React__namespace.Component));\nfunction AnimateLayoutContextProvider(props) {\n    var _a = tslib.__read(usePresence(), 2), safeToRemove = _a[1];\n    return React__namespace.createElement(Animate, tslib.__assign({}, props, { safeToRemove: safeToRemove }));\n}\nfunction hasMoved(a, b) {\n    return (!isZeroBox(a) &&\n        !isZeroBox(b) &&\n        (!axisIsEqual(a.x, b.x) || !axisIsEqual(a.y, b.y)));\n}\nvar zeroAxis = { min: 0, max: 0 };\nfunction isZeroBox(a) {\n    return axisIsEqual(a.x, zeroAxis) && axisIsEqual(a.y, zeroAxis);\n}\nfunction axisIsEqual(a, b) {\n    return a.min === b.min && a.max === b.max;\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox) {\n    return prevParent || (!prevParent && !(originBox || targetBox));\n}\n\n/**\n * Default handlers for batching VisualElements\n */\nvar defaultHandler = {\n    layoutReady: function (child) { return child.notifyLayoutReady(); },\n};\n/**\n * Create a batcher to process VisualElements\n */\nfunction createBatcher() {\n    var queue = new Set();\n    return {\n        add: function (child) { return queue.add(child); },\n        flush: function (_a) {\n            var _b = _a === void 0 ? defaultHandler : _a, layoutReady = _b.layoutReady, parent = _b.parent;\n            batchLayout(function (read, write) {\n                var order = Array.from(queue).sort(compareByDepth);\n                var ancestors = parent\n                    ? collectProjectingAncestors(parent)\n                    : [];\n                write(function () {\n                    var allElements = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(ancestors)), tslib.__read(order));\n                    allElements.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    order.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    ancestors.forEach(function (element) { return element.restoreTransform(); });\n                    order.forEach(layoutReady);\n                });\n                read(function () {\n                    /**\n                     * After all children have started animating, ensure any Entering components are set to Present.\n                     * If we add deferred animations (set up all animations and then start them in two loops) this\n                     * could be moved to the start loop. But it needs to happen after all the animations configs\n                     * are generated in AnimateSharedLayout as this relies on presence data\n                     */\n                    order.forEach(function (child) {\n                        if (child.isPresent)\n                            child.presence = Presence.Present;\n                    });\n                });\n                write(function () {\n                    /**\n                     * Starting these animations will have queued jobs on the frame loop. In some situations,\n                     * like when removing an element, these will be processed too late after the DOM is manipulated,\n                     * leaving a flash of incorrectly-projected content. By manually flushing these jobs\n                     * we ensure there's no flash.\n                     */\n                    sync.flushSync.preRender();\n                    sync.flushSync.render();\n                });\n                read(function () {\n                    /**\n                     * Schedule a callback at the end of the following frame to assign the latest projection\n                     * box to the prevViewportBox snapshot. Once global batching is in place this could be run\n                     * synchronously. But for now it ensures that if any nested `AnimateSharedLayout` top-level\n                     * child attempts to calculate its previous relative position against a prevViewportBox\n                     * it will be against its latest projection box instead, as the snapshot is useless beyond this\n                     * render.\n                     */\n                    sync__default['default'].postRender(function () {\n                        return order.forEach(assignProjectionToSnapshot);\n                    });\n                    queue.clear();\n                });\n            });\n            // TODO: Need to find a layout-synchronous way of flushing this\n            flushLayout();\n        },\n    };\n}\nfunction assignProjectionToSnapshot(child) {\n    child.prevViewportBox = child.projection.target;\n}\n\nvar SharedLayoutContext = React.createContext(createBatcher());\n/**\n * @internal\n */\nvar FramerTreeLayoutContext = React.createContext(createBatcher());\nfunction isSharedLayout(context) {\n    return !!context.forceUpdate;\n}\n\n/**\n * This component is responsible for scheduling the measuring of the motion component\n */\nvar Measure = /** @class */ (function (_super) {\n    tslib.__extends(Measure, _super);\n    function Measure() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * If this is a child of a SyncContext, register the VisualElement with it on mount.\n     */\n    Measure.prototype.componentDidMount = function () {\n        var _a = this.props, syncLayout = _a.syncLayout, framerSyncLayout = _a.framerSyncLayout, visualElement = _a.visualElement;\n        isSharedLayout(syncLayout) && syncLayout.register(visualElement);\n        isSharedLayout(framerSyncLayout) &&\n            framerSyncLayout.register(visualElement);\n        visualElement.onUnmount(function () {\n            if (isSharedLayout(syncLayout)) {\n                syncLayout.remove(visualElement);\n            }\n            if (isSharedLayout(framerSyncLayout)) {\n                framerSyncLayout.remove(visualElement);\n            }\n        });\n    };\n    /**\n     * If this is a child of a SyncContext, notify it that it needs to re-render. It will then\n     * handle the snapshotting.\n     *\n     * If it is stand-alone component, add it to the batcher.\n     */\n    Measure.prototype.getSnapshotBeforeUpdate = function () {\n        var _a = this.props, syncLayout = _a.syncLayout, visualElement = _a.visualElement;\n        if (isSharedLayout(syncLayout)) {\n            syncLayout.syncUpdate();\n        }\n        else {\n            snapshotViewportBox(visualElement);\n            syncLayout.add(visualElement);\n        }\n        return null;\n    };\n    Measure.prototype.componentDidUpdate = function () {\n        var syncLayout = this.props.syncLayout;\n        if (!isSharedLayout(syncLayout))\n            syncLayout.flush();\n    };\n    Measure.prototype.render = function () {\n        return null;\n    };\n    return Measure;\n}(React__default['default'].Component));\nfunction MeasureContextProvider(props) {\n    var syncLayout = React.useContext(SharedLayoutContext);\n    var framerSyncLayout = React.useContext(FramerTreeLayoutContext);\n    return (React__default['default'].createElement(Measure, tslib.__assign({}, props, { syncLayout: syncLayout, framerSyncLayout: framerSyncLayout })));\n}\n\nvar layoutAnimations = {\n    measureLayout: MeasureContextProvider,\n    layoutAnimation: AnimateLayoutContextProvider,\n};\n\nvar createProjectionState = function () { return ({\n    isEnabled: false,\n    isHydrated: false,\n    isTargetLocked: false,\n    target: axisBox(),\n    targetFinal: axisBox(),\n}); };\nfunction createLayoutState() {\n    return {\n        isHydrated: false,\n        layout: axisBox(),\n        layoutCorrected: axisBox(),\n        treeScale: { x: 1, y: 1 },\n        delta: delta(),\n        deltaFinal: delta(),\n        deltaTransform: \"\",\n    };\n}\nvar zeroLayout = createLayoutState();\n\n/**\n * Build a transform style that takes a calculated delta between the element's current\n * space on screen and projects it into the desired space.\n */\nfunction buildLayoutProjectionTransform(_a, treeScale, latestTransform) {\n    var x = _a.x, y = _a.y;\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 = x.translate / treeScale.x;\n    var yTranslate = y.translate / treeScale.y;\n    var transform = \"translate3d(\" + xTranslate + \"px, \" + yTranslate + \"px, 0) \";\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\" + rotate + \") \";\n        if (rotateX)\n            transform += \"rotateX(\" + rotateX + \") \";\n        if (rotateY)\n            transform += \"rotateY(\" + rotateY + \") \";\n    }\n    transform += \"scale(\" + x.scale + \", \" + y.scale + \")\";\n    return !latestTransform && transform === identityProjection ? \"\" : transform;\n}\n/**\n * Take the calculated delta origin and apply it as a transform string.\n */\nfunction buildLayoutProjectionTransformOrigin(_a) {\n    var deltaFinal = _a.deltaFinal;\n    return deltaFinal.x.origin * 100 + \"% \" + deltaFinal.y.origin * 100 + \"% 0\";\n}\nvar identityProjection = buildLayoutProjectionTransform(zeroLayout.delta, zeroLayout.treeScale, { x: 1, y: 1 });\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\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            return names.forEach(function (name) {\n                var _a;\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                var on = \"on\" + name;\n                var propListener = props[on];\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, tslib.__spreadArray([], tslib.__read(args)));\n        };\n    });\n    return lifecycles;\n}\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        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\nfunction updateLayoutDeltas(_a, _b, treePath, transformOrigin) {\n    var delta = _a.delta, layout = _a.layout, layoutCorrected = _a.layoutCorrected, treeScale = _a.treeScale;\n    var target = _b.target;\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    resetBox(layoutCorrected, layout);\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(layoutCorrected, treeScale, treePath);\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    updateBoxDelta(delta, layoutCorrected, target, transformOrigin);\n}\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\nfunction setCurrentViewportBox(visualElement) {\n    var projectionParent = visualElement.getProjectionParent();\n    if (!projectionParent) {\n        visualElement.rebaseProjectionTarget();\n        return;\n    }\n    var relativeOffset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n    eachAxis(function (axis) {\n        visualElement.setProjectionTargetAxis(axis, relativeOffset[axis].min, relativeOffset[axis].max, true);\n    });\n}\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, resetTransform = _a.resetTransform, restoreTransform = _a.restoreTransform, 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;\n        if (options === void 0) { options = {}; }\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 and onViewportBoxUpdate.\n         */\n        var lifecycles = createLifecycles();\n        /**\n         *\n         */\n        var projection = createProjectionState();\n        /**\n         * A reference to the nearest projecting parent. This is either\n         * undefined if we haven't looked for the nearest projecting parent,\n         * false if there is no parent performing layout projection, or a reference\n         * to the projecting parent.\n         */\n        var projectionParent;\n        /**\n         * This is a reference to the visual state of the \"lead\" visual element.\n         * Usually, this will be this visual element. But if it shares a layoutId\n         * with other visual elements, only one of them will be designated lead by\n         * AnimateSharedLayout. All the other visual elements will take on the visual\n         * appearance of the lead while they crossfade to it.\n         */\n        var leadProjection = projection;\n        var leadLatestValues = latestValues;\n        var unsubscribeFromLeadVisualElement;\n        /**\n         * The latest layout measurements and calculated projections. This\n         * is seperate from the target projection data in visualState as\n         * many visual elements might point to the same piece of visualState as\n         * a target, whereas they might each have different layouts and thus\n         * projection calculations needed to project into the same viewport box.\n         */\n        var layoutState = createLayoutState();\n        /**\n         *\n         */\n        var crossfader;\n        /**\n         * Keep track of whether the viewport box has been updated since the\n         * last time the layout projection was re-calculated.\n         */\n        var hasViewportBoxUpdated = false;\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         * x/y motion values that track the progress of initiated layout\n         * animations.\n         *\n         * TODO: Target for removal\n         */\n        var projectionTargetProgress;\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 = tslib.__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         *\n         */\n        function render() {\n            if (!instance)\n                return;\n            if (element.isProjectionReady()) {\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                applyBoxTransforms(leadProjection.targetFinal, leadProjection.target, leadLatestValues);\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                updateBoxDelta(layoutState.deltaFinal, layoutState.layoutCorrected, leadProjection.targetFinal, latestValues);\n            }\n            triggerBuild();\n            renderInstance(instance, renderState);\n        }\n        function triggerBuild() {\n            var valuesToRender = latestValues;\n            if (crossfader && crossfader.isActive()) {\n                var crossfadedValues = crossfader.getCrossfadeState(element);\n                if (crossfadedValues)\n                    valuesToRender = crossfadedValues;\n            }\n            build(element, renderState, valuesToRender, leadProjection, layoutState, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        function updateLayoutProjection() {\n            if (!element.isProjectionReady())\n                return;\n            var delta = layoutState.delta, treeScale = layoutState.treeScale;\n            var prevTreeScaleX = treeScale.x;\n            var prevTreeScaleY = treeScale.y;\n            var prevDeltaTransform = layoutState.deltaTransform;\n            updateLayoutDeltas(layoutState, leadProjection, element.path, latestValues);\n            hasViewportBoxUpdated &&\n                element.notifyViewportBoxUpdate(leadProjection.target, delta);\n            hasViewportBoxUpdated = false;\n            var deltaTransform = buildLayoutProjectionTransform(delta, treeScale);\n            if (deltaTransform !== prevDeltaTransform ||\n                // Also compare calculated treeScale, for values that rely on this only for scale correction\n                prevTreeScaleX !== treeScale.x ||\n                prevTreeScaleY !== treeScale.y) {\n                element.scheduleRender();\n            }\n            layoutState.deltaTransform = deltaTransform;\n        }\n        function updateTreeLayoutProjection() {\n            element.layoutTree.forEach(fireUpdateLayoutProjection);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync__default['default'].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 = tslib.__assign(tslib.__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             * An ancestor path back to the root visual element. This is used\n             * by layout projection to quickly recurse back up the tree.\n             */\n            path: parent ? tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(parent.path)), [parent]) : [], layoutTree: parent ? parent.layoutTree : new FlatTree(), \n            /**\n             *\n             */\n            presenceId: presenceId,\n            projection: projection, \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 AnimateSharedLayout, 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                instance = element.current = newInstance;\n                element.pointTo(element);\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n            },\n            /**\n             *\n             */\n            unmount: function () {\n                sync.cancelSync.update(update);\n                sync.cancelSync.render(render);\n                sync.cancelSync.preRender(element.updateLayoutProjection);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                element.stopLayoutAnimation();\n                element.layoutTree.remove(element);\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n                lifecycles.clearAllListeners();\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 () { 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             * A method that schedules an update to layout projections throughout\n             * the tree. We inherit from the parent so there's only ever one\n             * job scheduled on the next frame - that of the root visual element.\n             */\n            scheduleUpdateLayoutProjection: parent\n                ? parent.scheduleUpdateLayoutProjection\n                : function () {\n                    return sync__default['default'].preRender(element.updateTreeLayoutProjection, false, true);\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            // 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) { var _a; return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options); }, \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__default['default'].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                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; }, \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            // Layout projection ==============================\n            /**\n             * Enable layout projection for this visual element. Won't actually\n             * occur until we also have hydrated layout measurements.\n             */\n            enableLayoutProjection: function () {\n                projection.isEnabled = true;\n                element.layoutTree.add(element);\n            },\n            /**\n             * Lock the projection target, for instance when dragging, so\n             * nothing else can try and animate it.\n             */\n            lockProjectionTarget: function () {\n                projection.isTargetLocked = true;\n            },\n            unlockProjectionTarget: function () {\n                element.stopLayoutAnimation();\n                projection.isTargetLocked = false;\n            }, getLayoutState: function () { return layoutState; }, setCrossfader: function (newCrossfader) {\n                crossfader = newCrossfader;\n            }, isProjectionReady: function () {\n                return projection.isEnabled &&\n                    projection.isHydrated &&\n                    layoutState.isHydrated;\n            }, \n            /**\n             * Start a layout animation on a given axis.\n             */\n            startLayoutAnimation: function (axis, transition, isRelative) {\n                if (isRelative === void 0) { isRelative = false; }\n                var progress = element.getProjectionAnimationProgress()[axis];\n                var _a = isRelative\n                    ? projection.relativeTarget[axis]\n                    : projection.target[axis], min = _a.min, max = _a.max;\n                var length = max - min;\n                progress.clearListeners();\n                progress.set(min);\n                progress.set(min); // Set twice to hard-reset velocity\n                progress.onChange(function (v) {\n                    element.setProjectionTargetAxis(axis, v, v + length, isRelative);\n                });\n                return element.animateMotionValue(axis, progress, 0, transition);\n            },\n            /**\n             * Stop layout animations.\n             */\n            stopLayoutAnimation: function () {\n                eachAxis(function (axis) {\n                    return element.getProjectionAnimationProgress()[axis].stop();\n                });\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 (withTransform) {\n                if (withTransform === void 0) { withTransform = true; }\n                var viewportBox = measureViewportBox(instance, options);\n                if (!withTransform)\n                    removeBoxTransforms(viewportBox, latestValues);\n                return viewportBox;\n            },\n            /**\n             * Get the motion values tracking the layout animations on each\n             * axis. Lazy init if not already created.\n             */\n            getProjectionAnimationProgress: function () {\n                projectionTargetProgress || (projectionTargetProgress = {\n                    x: motionValue(0),\n                    y: motionValue(0),\n                });\n                return projectionTargetProgress;\n            },\n            /**\n             * Update the projection of a single axis. Schedule an update to\n             * the tree layout projection.\n             */\n            setProjectionTargetAxis: function (axis, min, max, isRelative) {\n                if (isRelative === void 0) { isRelative = false; }\n                var target;\n                if (isRelative) {\n                    if (!projection.relativeTarget) {\n                        projection.relativeTarget = axisBox();\n                    }\n                    target = projection.relativeTarget[axis];\n                }\n                else {\n                    projection.relativeTarget = undefined;\n                    target = projection.target[axis];\n                }\n                projection.isHydrated = true;\n                target.min = min;\n                target.max = max;\n                // Flag that we want to fire the onViewportBoxUpdate event handler\n                hasViewportBoxUpdated = true;\n                lifecycles.notifySetAxisTarget();\n            },\n            /**\n             * Rebase the projection target on top of the provided viewport box\n             * or the measured layout. This ensures that non-animating elements\n             * don't fall out of sync differences in measurements vs projections\n             * after a page scroll or other relayout.\n             */\n            rebaseProjectionTarget: function (force, box) {\n                if (box === void 0) { box = layoutState.layout; }\n                var _a = element.getProjectionAnimationProgress(), x = _a.x, y = _a.y;\n                var shouldRebase = !projection.relativeTarget &&\n                    !projection.isTargetLocked &&\n                    !x.isAnimating() &&\n                    !y.isAnimating();\n                if (force || shouldRebase) {\n                    eachAxis(function (axis) {\n                        var _a = box[axis], min = _a.min, max = _a.max;\n                        element.setProjectionTargetAxis(axis, min, max);\n                    });\n                }\n            },\n            /**\n             * Notify the visual element that its layout is up-to-date.\n             * Currently Animate.tsx uses this to check whether a layout animation\n             * needs to be performed.\n             */\n            notifyLayoutReady: function (config) {\n                setCurrentViewportBox(element);\n                element.notifyLayoutUpdate(layoutState.layout, element.prevViewportBox || layoutState.layout, config);\n            }, \n            /**\n             * Temporarily reset the transform of the instance.\n             */\n            resetTransform: function () { return resetTransform(element, instance, props); }, restoreTransform: function () { return restoreTransform(instance, renderState); }, updateLayoutProjection: updateLayoutProjection,\n            updateTreeLayoutProjection: function () {\n                element.layoutTree.forEach(fireResolveRelativeTargetBox);\n                /**\n                 * Schedule the projection updates at the end of the current preRender\n                 * step. This will ensure that all layout trees will first resolve\n                 * relative projection boxes into viewport boxes, and *then*\n                 * update projections.\n                 */\n                sync__default['default'].preRender(updateTreeLayoutProjection, false, true);\n                // sync.postRender(() => element.scheduleUpdateLayoutProjection())\n            },\n            getProjectionParent: function () {\n                if (projectionParent === undefined) {\n                    var foundParent = false;\n                    // Search backwards through the tree path\n                    for (var i = element.path.length - 1; i >= 0; i--) {\n                        var ancestor = element.path[i];\n                        if (ancestor.projection.isEnabled) {\n                            foundParent = ancestor;\n                            break;\n                        }\n                    }\n                    projectionParent = foundParent;\n                }\n                return projectionParent;\n            },\n            resolveRelativeTargetBox: function () {\n                var relativeParent = element.getProjectionParent();\n                if (!projection.relativeTarget || !relativeParent)\n                    return;\n                calcRelativeBox(projection, relativeParent.projection);\n                if (isDraggable(relativeParent)) {\n                    var target = projection.target;\n                    applyBoxTransforms(target, target, relativeParent.getLatestValues());\n                }\n            },\n            shouldResetTransform: function () {\n                return Boolean(props._layoutResetTransform);\n            },\n            /**\n             *\n             */\n            pointTo: function (newLead) {\n                leadProjection = newLead.projection;\n                leadLatestValues = newLead.getLatestValues();\n                /**\n                 * Subscribe to lead component's layout animations\n                 */\n                unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n                unsubscribeFromLeadVisualElement = popmotion.pipe(newLead.onSetAxisTarget(element.scheduleUpdateLayoutProjection), newLead.onLayoutAnimationComplete(function () {\n                    var _a;\n                    if (element.isPresent) {\n                        element.presence = Presence.Present;\n                    }\n                    else {\n                        (_a = element.layoutSafeToRemove) === null || _a === void 0 ? void 0 : _a.call(element);\n                    }\n                }));\n            }, \n            // TODO: Clean this up\n            isPresent: true, presence: Presence.Entering });\n        return element;\n    };\n};\nfunction fireResolveRelativeTargetBox(child) {\n    child.resolveRelativeTargetBox();\n}\nfunction fireUpdateLayoutProjection(child) {\n    child.updateLayoutProjection();\n}\nvar variantProps = tslib.__spreadArray([\"initial\"], tslib.__read(variantPriorityOrder));\nvar numVariantProps = variantProps.length;\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 === styleValueTypes.number || v === styleValueTypes.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) { 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}; };\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) {\n        var x = _a.x;\n        return x.max - x.min;\n    },\n    height: function (_a) {\n        var y = _a.y;\n        return y.max - y.min;\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, top = elementComputedStyle.top, left = elementComputedStyle.left, bottom = elementComputedStyle.bottom, right = elementComputedStyle.right, transform = elementComputedStyle.transform;\n    var originComputedStyle = { top: top, left: left, bottom: bottom, right: right, transform: transform };\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    // 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, positionalValues[key](originBbox, originComputedStyle));\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 = tslib.__assign({}, target);\n    transitionEnd = tslib.__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 to = target[key];\n        var fromType = findDimensionValueType(from);\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            for (var i = to[0] === null ? 1 : 0; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    heyListen.invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    heyListen.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 === styleValueTypes.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 = 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 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 = tslib.__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        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\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\nfunction getComputedStyle$1(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$1(domElement);\n            return ((isCSSVariable$1(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 getBoundingBox(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 = tslib.__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 tslib.__assign({ transition: transition,\n            transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n    build: function (element, renderState, latestValues, projection, layoutState, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n        buildHTMLStyles(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform\n            ? buildLayoutProjectionTransformOrigin\n            : undefined);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nvar svgVisualElement = visualElement(tslib.__assign(tslib.__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    },\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    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (_element, renderState, latestValues, projection, layoutState, options, props) {\n        var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n        buildSVGAttrs(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform\n            ? buildLayoutProjectionTransformOrigin\n            : undefined);\n    }, render: renderSVG }));\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nvar featureBundle = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, animations), gestureAnimations), drag), layoutAnimations);\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);\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));\n}\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nfunction useForceUpdate() {\n    var unloadingRef = React.useRef(false);\n    var _a = tslib.__read(React.useState(0), 2), forcedRenderCount = _a[0], setForcedRenderCount = _a[1];\n    useUnmountEffect(function () { return (unloadingRef.current = true); });\n    return React.useCallback(function () {\n        !unloadingRef.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n}\n\nvar presenceId = 0;\nfunction getPresenceId() {\n    var id = presenceId;\n    presenceId++;\n    return id;\n}\nvar PresenceChild = function (_a) {\n    var children = _a.children, initial = _a.initial, isPresent = _a.isPresent, onExitComplete = _a.onExitComplete, custom = _a.custom, presenceAffectsLayout = _a.presenceAffectsLayout;\n    var presenceChildren = useConstant(newChildrenMap);\n    var id = useConstant(getPresenceId);\n    var context = React.useMemo(function () { return ({\n        id: id,\n        initial: initial,\n        isPresent: isPresent,\n        custom: custom,\n        onExitComplete: function (childId) {\n            presenceChildren.set(childId, true);\n            var allComplete = true;\n            presenceChildren.forEach(function (isComplete) {\n                if (!isComplete)\n                    allComplete = false;\n            });\n            allComplete && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n        },\n        register: function (childId) {\n            presenceChildren.set(childId, false);\n            return function () { return presenceChildren.delete(childId); };\n        },\n    }); }, \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? undefined : [isPresent]);\n    React.useMemo(function () {\n        presenceChildren.forEach(function (_, key) { return presenceChildren.set(key, false); });\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React__namespace.useEffect(function () {\n        !isPresent && !presenceChildren.size && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n    }, [isPresent]);\n    return (React__namespace.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nfunction getChildKey(child) {\n    return child.key || \"\";\n}\nfunction updateChildLookup(children, allChildren) {\n    var seenChildren = process.env.NODE_ENV !== \"production\" ? new Set() : null;\n    children.forEach(function (child) {\n        var key = getChildKey(child);\n        if (process.env.NODE_ENV !== \"production\" && seenChildren) {\n            if (seenChildren.has(key)) {\n                console.warn(\"Children of AnimatePresence require unique keys. \\\"\" + key + \"\\\" is a duplicate.\");\n            }\n            seenChildren.add(key);\n        }\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    var filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    React.Children.forEach(children, function (child) {\n        if (React.isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * @library\n *\n * Any `Frame` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { Frame, AnimatePresence } from 'framer'\n *\n * // As items are added and removed from `items`\n * export function Items({ items }) {\n *   return (\n *     <AnimatePresence>\n *       {items.map(item => (\n *         <Frame\n *           key={item.id}\n *           initial={{ opacity: 0 }}\n *           animate={{ opacity: 1 }}\n *           exit={{ opacity: 0 }}\n *         />\n *       ))}\n *     </AnimatePresence>\n *   )\n * }\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * @motion\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nvar AnimatePresence = function (_a) {\n    var children = _a.children, custom = _a.custom, _b = _a.initial, initial = _b === void 0 ? true : _b, onExitComplete = _a.onExitComplete, exitBeforeEnter = _a.exitBeforeEnter, _c = _a.presenceAffectsLayout, presenceAffectsLayout = _c === void 0 ? true : _c;\n    // We want to force a re-render once all exiting animations have finished. We\n    // either use a local forceRender function, or one from a parent context if it exists.\n    var forceRender = useForceUpdate();\n    var layoutContext = React.useContext(SharedLayoutContext);\n    if (isSharedLayout(layoutContext)) {\n        forceRender = layoutContext.forceUpdate;\n    }\n    var isInitialRender = React.useRef(true);\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    var filteredChildren = onlyElements(children);\n    // Keep a living record of the children we're actually rendering so we\n    // can diff to figure out which are entering and exiting\n    var presentChildren = React.useRef(filteredChildren);\n    // A lookup table to quickly reference components by key\n    var allChildren = React.useRef(new Map())\n        .current;\n    // A living record of all currently exiting components.\n    var exiting = React.useRef(new Set()).current;\n    updateChildLookup(filteredChildren, allChildren);\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    if (isInitialRender.current) {\n        isInitialRender.current = false;\n        return (React__namespace.createElement(React__namespace.Fragment, null, filteredChildren.map(function (child) { return (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)); })));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    var childrenToRender = tslib.__spreadArray([], tslib.__read(filteredChildren));\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    var presentKeys = presentChildren.current.map(getChildKey);\n    var targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    var numPresent = presentKeys.length;\n    for (var i = 0; i < numPresent; i++) {\n        var key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1) {\n            exiting.add(key);\n        }\n        else {\n            // In case this key has re-entered, remove from the exiting list\n            exiting.delete(key);\n        }\n    }\n    // If we currently have exiting children, and we're deferring rendering incoming children\n    // until after all current children have exiting, empty the childrenToRender array\n    if (exitBeforeEnter && exiting.size) {\n        childrenToRender = [];\n    }\n    // Loop through all currently exiting components and clone them to overwrite `animate`\n    // with any `exit` prop they might have defined.\n    exiting.forEach(function (key) {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        var child = allChildren.get(key);\n        if (!child)\n            return;\n        var insertionIndex = presentKeys.indexOf(key);\n        var onExit = function () {\n            allChildren.delete(key);\n            exiting.delete(key);\n            // Remove this child from the present children\n            var removeIndex = presentChildren.current.findIndex(function (presentChild) { return presentChild.key === key; });\n            presentChildren.current.splice(removeIndex, 1);\n            // Defer re-rendering until all exiting children have indeed left\n            if (!exiting.size) {\n                presentChildren.current = filteredChildren;\n                forceRender();\n                onExitComplete && onExitComplete();\n            }\n        };\n        childrenToRender.splice(insertionIndex, 0, React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    // Add `MotionContext` even to children that don't need it to ensure we're rendering\n    // the same tree between renders\n    childrenToRender = childrenToRender.map(function (child) {\n        var key = child.key;\n        return exiting.has(key) ? (child) : (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    presentChildren.current = childrenToRender;\n    if (process.env.NODE_ENV !== \"production\" &&\n        exitBeforeEnter &&\n        childrenToRender.length > 1) {\n        console.warn(\"You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour.\");\n    }\n    return (React__namespace.createElement(React__namespace.Fragment, null, exiting.size\n        ? childrenToRender\n        : childrenToRender.map(function (child) { return React.cloneElement(child); })));\n};\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    };\n}\n\nfunction createCrossfader() {\n    /**\n     * The current state of the crossfade as a value between 0 and 1\n     */\n    var progress = motionValue(1);\n    var options = {\n        lead: undefined,\n        follow: undefined,\n        crossfadeOpacity: false,\n        preserveFollowOpacity: false,\n    };\n    var prevOptions = tslib.__assign({}, options);\n    var leadState = {};\n    var followState = {};\n    /**\n     *\n     */\n    var isActive = false;\n    /**\n     *\n     */\n    var finalCrossfadeFrame = null;\n    /**\n     * Framestamp of the last frame we updated values at.\n     */\n    var prevUpdate = 0;\n    function startCrossfadeAnimation(target, transition) {\n        var lead = options.lead, follow = options.follow;\n        isActive = true;\n        finalCrossfadeFrame = null;\n        var hasUpdated = false;\n        var onUpdate = function () {\n            hasUpdated = true;\n            lead && lead.scheduleRender();\n            follow && follow.scheduleRender();\n        };\n        var onComplete = function () {\n            isActive = false;\n            /**\n             * If the crossfade animation is no longer active, flag a frame\n             * that we're still allowed to crossfade\n             */\n            finalCrossfadeFrame = sync.getFrameData().timestamp;\n        };\n        transition = transition && getValueTransition(transition, \"crossfade\");\n        return animate(progress, target, tslib.__assign(tslib.__assign({}, transition), { onUpdate: onUpdate, onComplete: function () {\n                if (!hasUpdated) {\n                    progress.set(target);\n                    /**\n                     * If we never ran an update, for instance if this was an instant transition, fire a\n                     * simulated final frame to ensure the crossfade gets applied correctly.\n                     */\n                    sync__default['default'].read(onComplete);\n                }\n                else {\n                    onComplete();\n                }\n                onUpdate();\n            } }));\n    }\n    function updateCrossfade() {\n        var _a, _b;\n        /**\n         * We only want to compute the crossfade once per frame, so we\n         * compare the previous update framestamp with the current frame\n         * and early return if they're the same.\n         */\n        var timestamp = sync.getFrameData().timestamp;\n        var lead = options.lead, follow = options.follow;\n        if (timestamp === prevUpdate || !lead)\n            return;\n        prevUpdate = timestamp;\n        /**\n         * Merge each component's latest values into our crossfaded state\n         * before crossfading.\n         */\n        var latestLeadValues = lead.getLatestValues();\n        Object.assign(leadState, latestLeadValues);\n        var latestFollowValues = follow\n            ? follow.getLatestValues()\n            : options.prevValues;\n        Object.assign(followState, latestFollowValues);\n        var p = progress.get();\n        /**\n         * Crossfade the opacity between the two components. This will result\n         * in a different opacity for each component.\n         */\n        var leadTargetOpacity = (_a = latestLeadValues.opacity) !== null && _a !== void 0 ? _a : 1;\n        var followTargetOpacity = (_b = latestFollowValues === null || latestFollowValues === void 0 ? void 0 : latestFollowValues.opacity) !== null && _b !== void 0 ? _b : 1;\n        if (options.crossfadeOpacity && follow) {\n            leadState.opacity = popmotion.mix(\n            /**\n             * If the follow child has been completely hidden we animate\n             * this opacity from its previous opacity, but otherwise from completely transparent.\n             */\n            follow.isVisible !== false ? 0 : followTargetOpacity, leadTargetOpacity, easeCrossfadeIn(p));\n            followState.opacity = options.preserveFollowOpacity\n                ? followTargetOpacity\n                : popmotion.mix(followTargetOpacity, 0, easeCrossfadeOut(p));\n        }\n        else if (!follow) {\n            leadState.opacity = popmotion.mix(followTargetOpacity, leadTargetOpacity, p);\n        }\n        mixValues(leadState, followState, latestLeadValues, latestFollowValues || {}, Boolean(follow), p);\n    }\n    return {\n        isActive: function () {\n            return leadState &&\n                (isActive || sync.getFrameData().timestamp === finalCrossfadeFrame);\n        },\n        fromLead: function (transition) {\n            return startCrossfadeAnimation(0, transition);\n        },\n        toLead: function (transition) {\n            var initialProgress = 0;\n            if (!options.prevValues && !options.follow) {\n                /**\n                 * If we're not coming from anywhere, start at the end of the animation.\n                 */\n                initialProgress = 1;\n            }\n            else if (prevOptions.lead === options.follow &&\n                prevOptions.follow === options.lead) {\n                /**\n                 * If we're swapping follow/lead we can reverse the progress\n                 */\n                initialProgress = 1 - progress.get();\n            }\n            progress.set(initialProgress);\n            return startCrossfadeAnimation(1, transition);\n        },\n        reset: function () { return progress.set(1); },\n        stop: function () { return progress.stop(); },\n        getCrossfadeState: function (element) {\n            updateCrossfade();\n            if (element === options.lead) {\n                return leadState;\n            }\n            else if (element === options.follow) {\n                return followState;\n            }\n        },\n        setOptions: function (newOptions) {\n            prevOptions = options;\n            options = newOptions;\n            leadState = {};\n            followState = {};\n        },\n        getLatestValues: function () {\n            return leadState;\n        },\n    };\n}\nvar easeCrossfadeIn = compress(0, 0.5, popmotion.circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, popmotion.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(popmotion.progress(min, max, p));\n    };\n}\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nfunction mixValues(leadState, followState, latestLeadValues, latestFollowValues, hasFollowElement, p) {\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\" + borders[i] + \"Radius\";\n        var followRadius = getRadius(latestFollowValues, borderLabel);\n        var leadRadius = getRadius(latestLeadValues, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        /**\n         * Currently we're only crossfading between numerical border radius.\n         * It would be possible to crossfade between percentages for a little\n         * extra bundle size.\n         */\n        if (typeof followRadius === \"number\" &&\n            typeof leadRadius === \"number\") {\n            var radius = Math.max(popmotion.mix(followRadius, leadRadius, p), 0);\n            leadState[borderLabel] = followState[borderLabel] = radius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (latestFollowValues.rotate || latestLeadValues.rotate) {\n        var rotate = popmotion.mix(latestFollowValues.rotate || 0, latestLeadValues.rotate || 0, p);\n        leadState.rotate = followState.rotate = rotate;\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 (!hasFollowElement &&\n        latestLeadValues.backgroundColor &&\n        latestFollowValues.backgroundColor) {\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 = popmotion.mixColor(latestFollowValues.backgroundColor, latestLeadValues.backgroundColor)(p);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n\nfunction layoutStack() {\n    var stack = new Set();\n    var state = { leadIsExiting: false };\n    var prevState = tslib.__assign({}, state);\n    var prevValues;\n    var prevViewportBox;\n    var prevDragCursor;\n    var crossfader = createCrossfader();\n    var needsCrossfadeAnimation = false;\n    function getFollowViewportBox() {\n        return state.follow ? state.follow.prevViewportBox : prevViewportBox;\n    }\n    function getFollowLayout() {\n        var _a;\n        return (_a = state.follow) === null || _a === void 0 ? void 0 : _a.getLayoutState().layout;\n    }\n    return {\n        add: function (element) {\n            element.setCrossfader(crossfader);\n            stack.add(element);\n            /**\n             * Hydrate new element with previous drag position if we have one\n             */\n            if (prevDragCursor)\n                element.prevDragCursor = prevDragCursor;\n            if (!state.lead)\n                state.lead = element;\n        },\n        remove: function (element) {\n            stack.delete(element);\n        },\n        getLead: function () { return state.lead; },\n        updateSnapshot: function () {\n            if (!state.lead)\n                return;\n            prevValues = crossfader.isActive()\n                ? crossfader.getLatestValues()\n                : state.lead.getLatestValues();\n            prevViewportBox = state.lead.prevViewportBox;\n            var dragControls = elementDragControls.get(state.lead);\n            if (dragControls && dragControls.isDragging) {\n                prevDragCursor = dragControls.cursorProgress;\n            }\n        },\n        clearSnapshot: function () {\n            prevDragCursor = prevViewportBox = undefined;\n        },\n        updateLeadAndFollow: function () {\n            var _a;\n            prevState = tslib.__assign({}, state);\n            var lead;\n            var follow;\n            var order = Array.from(stack);\n            for (var i = order.length; i--; i >= 0) {\n                var element = order[i];\n                if (lead)\n                    follow !== null && follow !== void 0 ? follow : (follow = element);\n                lead !== null && lead !== void 0 ? lead : (lead = element);\n                if (lead && follow)\n                    break;\n            }\n            state.lead = lead;\n            state.follow = follow;\n            state.leadIsExiting = ((_a = state.lead) === null || _a === void 0 ? void 0 : _a.presence) === Presence.Exiting;\n            crossfader.setOptions({\n                lead: lead,\n                follow: follow,\n                prevValues: prevValues,\n                crossfadeOpacity: (follow === null || follow === void 0 ? void 0 : follow.isPresenceRoot) || (lead === null || lead === void 0 ? void 0 : lead.isPresenceRoot),\n            });\n            if (\n            // Don't crossfade if we've just animated back from lead and switched the\n            // old follow to the new lead.\n            state.lead !== prevState.follow &&\n                (prevState.lead !== state.lead ||\n                    prevState.leadIsExiting !== state.leadIsExiting)) {\n                needsCrossfadeAnimation = true;\n            }\n        },\n        animate: function (child, shouldCrossfade) {\n            var _a;\n            if (shouldCrossfade === void 0) { shouldCrossfade = false; }\n            if (child === state.lead) {\n                if (shouldCrossfade) {\n                    /**\n                     * Point a lead to itself in case it was previously pointing\n                     * to a different visual element\n                     */\n                    child.pointTo(state.lead);\n                }\n                else {\n                    child.setVisibility(true);\n                }\n                var config = {};\n                var prevParent = (_a = state.follow) === null || _a === void 0 ? void 0 : _a.getProjectionParent();\n                if (prevParent) {\n                    /**\n                     * We'll use this to determine if the element or its layoutId has been reparented.\n                     */\n                    config.prevParent = prevParent;\n                }\n                if (child.presence === Presence.Entering) {\n                    config.originBox = getFollowViewportBox();\n                }\n                else if (child.presence === Presence.Exiting) {\n                    config.targetBox = getFollowLayout();\n                }\n                if (needsCrossfadeAnimation) {\n                    needsCrossfadeAnimation = false;\n                    var transition = child.getDefaultTransition();\n                    child.presence === Presence.Entering\n                        ? crossfader.toLead(transition)\n                        : crossfader.fromLead(transition);\n                }\n                child.notifyLayoutReady(config);\n            }\n            else {\n                if (shouldCrossfade) {\n                    state.lead && child.pointTo(state.lead);\n                }\n                else {\n                    child.setVisibility(false);\n                }\n            }\n        },\n    };\n}\n\nfunction resetRotate(child) {\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 (!child.hasValue(key) || child.getStaticValue(key) === 0)\n            continue;\n        hasRotate = true;\n        // Record the rotation and then temporarily set it to 0\n        resetValues[key] = child.getStaticValue(key);\n        child.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    child.syncRender();\n    // Put back all the values we reset\n    for (var key in resetValues) {\n        child.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    child.scheduleRender();\n}\n\n/**\n * @public\n */\nvar AnimateSharedLayout = /** @class */ (function (_super) {\n    tslib.__extends(AnimateSharedLayout, _super);\n    function AnimateSharedLayout() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /**\n         * A list of all the children in the shared layout\n         */\n        _this.children = new Set();\n        /**\n         * As animate components with a defined `layoutId` are added/removed to the tree,\n         * we store them in order. When one is added, it will animate out from the\n         * previous one, and when it's removed, it'll animate to the previous one.\n         */\n        _this.stacks = new Map();\n        /**\n         * Track whether the component has mounted. If it hasn't, the presence of added children\n         * are set to Present, whereas if it has they're considered Entering\n         */\n        _this.hasMounted = false;\n        /**\n         * Track whether we already have an update scheduled. If we don't, we'll run snapshots\n         * and schedule one.\n         */\n        _this.updateScheduled = false;\n        /**\n         * Tracks whether we already have a render scheduled. If we don't, we'll force one with this.forceRender\n         */\n        _this.renderScheduled = false;\n        /**\n         * The methods provided to all children in the shared layout tree.\n         */\n        _this.syncContext = tslib.__assign(tslib.__assign({}, createBatcher()), { syncUpdate: function (force) { return _this.scheduleUpdate(force); }, forceUpdate: function () {\n                // By copying syncContext to itself, when this component re-renders it'll also re-render\n                // all children subscribed to the SharedLayout context.\n                _this.syncContext = tslib.__assign({}, _this.syncContext);\n                _this.scheduleUpdate(true);\n            }, register: function (child) { return _this.addChild(child); }, remove: function (child) { return _this.removeChild(child); } });\n        return _this;\n    }\n    AnimateSharedLayout.prototype.componentDidMount = function () {\n        this.hasMounted = true;\n    };\n    AnimateSharedLayout.prototype.componentDidUpdate = function () {\n        this.startLayoutAnimation();\n    };\n    AnimateSharedLayout.prototype.shouldComponentUpdate = function () {\n        this.renderScheduled = true;\n        return true;\n    };\n    AnimateSharedLayout.prototype.startLayoutAnimation = function () {\n        var _this = this;\n        /**\n         * Reset update and render scheduled status\n         */\n        this.renderScheduled = this.updateScheduled = false;\n        var type = this.props.type;\n        /**\n         * Update presence metadata based on the latest AnimatePresence status.\n         * This is a kind of goofy way of dealing with this, perhaps there's a better model to find.\n         */\n        this.children.forEach(function (child) {\n            if (!child.isPresent) {\n                child.presence = Presence.Exiting;\n            }\n            else if (child.presence !== Presence.Entering) {\n                child.presence =\n                    child.presence === Presence.Exiting\n                        ? Presence.Entering\n                        : Presence.Present;\n            }\n        });\n        this.updateStacks();\n        /**\n         * Create a handler which we can use to flush the children animations\n         */\n        var handler = {\n            layoutReady: function (child) {\n                if (child.getLayoutId() !== undefined) {\n                    var stack = _this.getStack(child);\n                    stack.animate(child, type === \"crossfade\");\n                }\n                else {\n                    child.notifyLayoutReady();\n                }\n            },\n            parent: this.context.visualElement,\n        };\n        /**\n         * Shared layout animations can be used without the AnimateSharedLayout wrapping component.\n         * This requires some co-ordination across components to stop layout thrashing\n         * and ensure measurements are taken at the correct time.\n         *\n         * Here we use that same mechanism of schedule/flush.\n         */\n        this.children.forEach(function (child) { return _this.syncContext.add(child); });\n        this.syncContext.flush(handler);\n        /**\n         * Clear snapshots so subsequent rerenders don't retain memory of outgoing components\n         */\n        this.stacks.forEach(function (stack) { return stack.clearSnapshot(); });\n    };\n    AnimateSharedLayout.prototype.updateStacks = function () {\n        this.stacks.forEach(function (stack) { return stack.updateLeadAndFollow(); });\n    };\n    AnimateSharedLayout.prototype.scheduleUpdate = function (force) {\n        if (force === void 0) { force = false; }\n        if (!(force || !this.updateScheduled))\n            return;\n        /**\n         * Flag we've scheduled an update\n         */\n        this.updateScheduled = true;\n        /**\n         * Write: Reset transforms so bounding boxes can be accurately measured.\n         */\n        this.children.forEach(function (child) {\n            resetRotate(child);\n            if (child.shouldResetTransform())\n                child.resetTransform();\n        });\n        /**\n         * Read: Snapshot children\n         */\n        this.children.forEach(snapshotViewportBox);\n        /**\n         * Every child keeps a local snapshot, but we also want to record\n         * snapshots of the visible children as, if they're are being removed\n         * in this render, we can still access them.\n         *\n         * TODO: What would be better here is doing a single loop where we\n         * only snapshotViewportBoxes of undefined layoutIds and then one for each stack\n         */\n        this.stacks.forEach(function (stack) { return stack.updateSnapshot(); });\n        /**\n         * Force a rerender by setting state if we aren't already going to render.\n         */\n        if (force || !this.renderScheduled) {\n            this.renderScheduled = true;\n            this.forceUpdate();\n        }\n    };\n    AnimateSharedLayout.prototype.addChild = function (child) {\n        this.children.add(child);\n        this.addToStack(child);\n        child.presence = this.hasMounted ? Presence.Entering : Presence.Present;\n    };\n    AnimateSharedLayout.prototype.removeChild = function (child) {\n        this.scheduleUpdate();\n        this.children.delete(child);\n        this.removeFromStack(child);\n    };\n    AnimateSharedLayout.prototype.addToStack = function (child) {\n        var stack = this.getStack(child);\n        stack === null || stack === void 0 ? void 0 : stack.add(child);\n    };\n    AnimateSharedLayout.prototype.removeFromStack = function (child) {\n        var stack = this.getStack(child);\n        stack === null || stack === void 0 ? void 0 : stack.remove(child);\n    };\n    /**\n     * Return a stack of animate children based on the provided layoutId.\n     * Will create a stack if none currently exists with that layoutId.\n     */\n    AnimateSharedLayout.prototype.getStack = function (child) {\n        var id = child.getLayoutId();\n        if (id === undefined)\n            return;\n        // Create stack if it doesn't already exist\n        !this.stacks.has(id) && this.stacks.set(id, layoutStack());\n        return this.stacks.get(id);\n    };\n    AnimateSharedLayout.prototype.render = function () {\n        return (React__namespace.createElement(SharedLayoutContext.Provider, { value: this.syncContext }, this.props.children));\n    };\n    AnimateSharedLayout.contextType = MotionContext;\n    return AnimateSharedLayout;\n}(React__namespace.Component));\n\n/**\n * `MotionConfig` is used to set configuration options for all children `motion` components.\n *\n * ```jsx\n * import { motion, MotionConfig } from \"framer-motion\"\n *\n * export function App() {\n *   return (\n *     <MotionConfig transition={{ type: \"spring\" }}>\n *       <motion.div animate={{ x: 100 }} />\n *     </MotionConfig>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction MotionConfig(_a) {\n    var children = _a.children, config = tslib.__rest(_a, [\"children\"]);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = tslib.__assign(tslib.__assign({}, React.useContext(MotionConfigContext)), config);\n    /**\n     * Don't allow isStatic to change between renders as it affects how many hooks\n     * motion components fire.\n     */\n    config.isStatic = useConstant(function () { return config.isStatic; });\n    /**\n     * Creating a new config context object will re-render every `motion` component\n     * every time it renders. So we only want to create a new one sparingly.\n     */\n    var transitionDependency = typeof config.transition === \"object\"\n        ? config.transition.toString()\n        : \"\";\n    var context = React.useMemo(function () { return config; }, [\n        transitionDependency,\n        config.transformPagePoint,\n    ]);\n    return (React__namespace.createElement(MotionConfigContext.Provider, { value: context }, children));\n}\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = tslib.__read(React.useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = React.useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = tslib.__rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    React.useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = tslib.__rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React__namespace.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\n/**\n * @public\n */\nvar domAnimation = tslib.__assign(tslib.__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\n/**\n * @public\n */\nvar domMax = tslib.__assign(tslib.__assign(tslib.__assign({}, domAnimation), drag), layoutAnimations);\n\n/**\n * Creates a `MotionValue` to track the state and velocity of a value.\n *\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\n *\n * @library\n *\n * ```jsx\n * export function MyComponent() {\n *   const scale = useMotionValue(1)\n *\n *   return <Frame scale={scale} />\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const scale = useMotionValue(1)\n *\n *   return <motion.div style={{ scale }} />\n * }\n * ```\n *\n * @param initial - The initial state.\n *\n * @public\n */\nfunction useMotionValue(initial) {\n    var value = useConstant(function () { return motionValue(initial); });\n    /**\n     * If this motion value is being used in static mode, like on\n     * the Framer canvas, force components to rerender when the motion\n     * value is updated.\n     */\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    if (isStatic) {\n        var _a = tslib.__read(React.useState(initial), 2), setLatest_1 = _a[1];\n        React.useEffect(function () { return value.onChange(setLatest_1); }, []);\n    }\n    return value;\n}\n\nfunction useOnChange(value, callback) {\n    React.useEffect(function () {\n        if (isMotionValue(value))\n            return value.onChange(callback);\n    }, [callback]);\n}\nfunction useMultiOnChange(values, handler) {\n    React.useEffect(function () {\n        var subscriptions = values.map(function (value) { return value.onChange(handler); });\n        return function () { return subscriptions.forEach(function (unsubscribe) { return unsubscribe(); }); };\n    });\n}\n\nfunction useCombineMotionValues(values, combineValues) {\n    /**\n     * Initialise the returned motion value. This remains the same between renders.\n     */\n    var value = useMotionValue(combineValues());\n    /**\n     * Create a function that will update the template motion value with the latest values.\n     * This is pre-bound so whenever a motion value updates it can schedule its\n     * execution in Framesync. If it's already been scheduled it won't be fired twice\n     * in a single frame.\n     */\n    var updateValue = function () { return value.set(combineValues()); };\n    /**\n     * Synchronously update the motion value with the latest values during the render.\n     * This ensures that within a React render, the styles applied to the DOM are up-to-date.\n     */\n    updateValue();\n    /**\n     * Subscribe to all motion values found within the template. Whenever any of them change,\n     * schedule an update.\n     */\n    useMultiOnChange(values, function () { return sync__default['default'].update(updateValue, false, true); });\n    return value;\n}\n\n/**\n * Combine multiple motion values into a new one using a string template literal.\n *\n * ```jsx\n * import {\n *   motion,\n *   useSpring,\n *   useMotionValue,\n *   useMotionTemplate\n * } from \"framer-motion\"\n *\n * function Component() {\n *   const shadowX = useSpring(0)\n *   const shadowY = useMotionValue(0)\n *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`\n *\n *   return <motion.div style={{ filter: shadow }} />\n * }\n * ```\n *\n * @public\n */\nfunction useMotionTemplate(fragments) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    /**\n     * Create a function that will build a string from the latest motion values.\n     */\n    var numFragments = fragments.length;\n    function buildValue() {\n        var output = \"\";\n        for (var i = 0; i < numFragments; i++) {\n            output += fragments[i];\n            var value = values[i];\n            if (value)\n                output += values[i].get();\n        }\n        return output;\n    }\n    return useCombineMotionValues(values, buildValue);\n}\n\nvar isCustomValueType = function (v) {\n    return typeof v === \"object\" && v.mix;\n};\nvar getMixer = function (v) { return (isCustomValueType(v) ? v.mix : undefined); };\nfunction transform() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var useImmediate = !Array.isArray(args[0]);\n    var argOffset = useImmediate ? 0 : -1;\n    var inputValue = args[0 + argOffset];\n    var inputRange = args[1 + argOffset];\n    var outputRange = args[2 + argOffset];\n    var options = args[3 + argOffset];\n    var interpolator = popmotion.interpolate(inputRange, outputRange, tslib.__assign({ mixer: getMixer(outputRange[0]) }, options));\n    return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\nfunction useTransform(input, inputRangeOrTransformer, outputRange, options) {\n    var transformer = typeof inputRangeOrTransformer === \"function\"\n        ? inputRangeOrTransformer\n        : transform(inputRangeOrTransformer, outputRange, options);\n    return Array.isArray(input)\n        ? useListTransform(input, transformer)\n        : useListTransform([input], function (_a) {\n            var _b = tslib.__read(_a, 1), latest = _b[0];\n            return transformer(latest);\n        });\n}\nfunction useListTransform(values, transformer) {\n    var latest = useConstant(function () { return []; });\n    return useCombineMotionValues(values, function () {\n        latest.length = 0;\n        var numValues = values.length;\n        for (var i = 0; i < numValues; i++) {\n            latest[i] = values[i].get();\n        }\n        return transformer(latest);\n    });\n}\n\n/**\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\n *\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\n * to another `MotionValue`.\n *\n * @remarks\n *\n * ```jsx\n * const x = useSpring(0, { stiffness: 300 })\n * const y = useSpring(x, { damping: 10 })\n * ```\n *\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\n * @param springConfig - Configuration options for the spring.\n * @returns `MotionValue`\n *\n * @public\n */\nfunction useSpring(source, config) {\n    if (config === void 0) { config = {}; }\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    var activeSpringAnimation = React.useRef(null);\n    var value = useMotionValue(isMotionValue(source) ? source.get() : source);\n    React.useMemo(function () {\n        return value.attach(function (v, set) {\n            /**\n             * A more hollistic approach to this might be to use isStatic to fix VisualElement animations\n             * at that level, but this will work for now\n             */\n            if (isStatic)\n                return set(v);\n            if (activeSpringAnimation.current) {\n                activeSpringAnimation.current.stop();\n            }\n            activeSpringAnimation.current = popmotion.animate(tslib.__assign(tslib.__assign({ from: value.get(), to: v, velocity: value.getVelocity() }, config), { onUpdate: set }));\n            return value.get();\n        });\n    }, Object.values(config));\n    useOnChange(source, function (v) { return value.set(parseFloat(v)); });\n    return value;\n}\n\n/**\n * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.\n *\n * ```javascript\n * const x = useMotionValue(0)\n * const xVelocity = useVelocity(x)\n * const xAcceleration = useVelocity(xVelocity)\n * ```\n *\n * @public\n */\nfunction useVelocity(value) {\n    var velocity = useMotionValue(value.getVelocity());\n    React.useEffect(function () {\n        return value.velocityUpdateSubscribers.add(function (newVelocity) {\n            velocity.set(newVelocity);\n        });\n    }, [value]);\n    return velocity;\n}\n\nfunction createScrollMotionValues() {\n    return {\n        scrollX: motionValue(0),\n        scrollY: motionValue(0),\n        scrollXProgress: motionValue(0),\n        scrollYProgress: motionValue(0),\n    };\n}\nfunction setProgress(offset, maxOffset, value) {\n    value.set(!offset || !maxOffset ? 0 : offset / maxOffset);\n}\nfunction createScrollUpdater(values, getOffsets) {\n    var update = function () {\n        var _a = getOffsets(), xOffset = _a.xOffset, yOffset = _a.yOffset, xMaxOffset = _a.xMaxOffset, yMaxOffset = _a.yMaxOffset;\n        // Set absolute positions\n        values.scrollX.set(xOffset);\n        values.scrollY.set(yOffset);\n        // Set 0-1 progress\n        setProgress(xOffset, xMaxOffset, values.scrollXProgress);\n        setProgress(yOffset, yMaxOffset, values.scrollYProgress);\n    };\n    update();\n    return update;\n}\n\nvar getElementScrollOffsets = function (element) { return function () {\n    return {\n        xOffset: element.scrollLeft,\n        yOffset: element.scrollTop,\n        xMaxOffset: element.scrollWidth - element.offsetWidth,\n        yMaxOffset: element.scrollHeight - element.offsetHeight,\n    };\n}; };\n/**\n * Returns MotionValues that update when the provided element scrolls:\n *\n * - `scrollX` — Horizontal scroll distance in pixels.\n * - `scrollY` — Vertical scroll distance in pixels.\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\n *\n * This element must be set to `overflow: scroll` on either or both axes to report scroll offset.\n *\n * @library\n *\n * ```jsx\n * import * as React from \"react\"\n * import {\n *   Frame,\n *   useElementScroll,\n *   useTransform\n * } from \"framer\"\n *\n * export function MyComponent() {\n *   const ref = React.useRef()\n *   const { scrollYProgress } = useElementScroll(ref)\n *\n *   return (\n *     <Frame ref={ref}>\n *       <Frame scaleX={scrollYProgress} />\n *     </Frame>\n *   )\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const ref = useRef()\n *   const { scrollYProgress } = useElementScroll(ref)\n *\n *   return (\n *     <div ref={ref}>\n *       <motion.div style={{ scaleX: scrollYProgress }} />\n *     </div>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction useElementScroll(ref) {\n    var values = useConstant(createScrollMotionValues);\n    useIsomorphicLayoutEffect(function () {\n        var element = ref.current;\n        heyListen.invariant(!!element, \"ref provided to useScroll must be passed into a HTML element.\");\n        if (!element)\n            return;\n        var updateScrollValues = createScrollUpdater(values, getElementScrollOffsets(element));\n        var scrollListener = addDomEvent(element, \"scroll\", updateScrollValues, { passive: true });\n        var resizeListener = addDomEvent(element, \"resize\", updateScrollValues);\n        return function () {\n            scrollListener && scrollListener();\n            resizeListener && resizeListener();\n        };\n    }, []);\n    return values;\n}\n\nvar viewportScrollValues;\nfunction getViewportScrollOffsets() {\n    return {\n        xOffset: window.pageXOffset,\n        yOffset: window.pageYOffset,\n        xMaxOffset: document.body.clientWidth - window.innerWidth,\n        yMaxOffset: document.body.clientHeight - window.innerHeight,\n    };\n}\nvar hasListeners = false;\nfunction addEventListeners() {\n    hasListeners = true;\n    if (typeof window === \"undefined\")\n        return;\n    var updateScrollValues = createScrollUpdater(viewportScrollValues, getViewportScrollOffsets);\n    addDomEvent(window, \"scroll\", updateScrollValues, { passive: true });\n    addDomEvent(window, \"resize\", updateScrollValues);\n}\n/**\n * Returns MotionValues that update when the viewport scrolls:\n *\n * - `scrollX` — Horizontal scroll distance in pixels.\n * - `scrollY` — Vertical scroll distance in pixels.\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\n *\n * **Warning:** Setting `body` or `html` to `height: 100%` or similar will break the `Progress`\n * values as this breaks the browser's capability to accurately measure the page length.\n *\n * @library\n *\n * ```jsx\n * import * as React from \"react\"\n * import {\n *   Frame,\n *   useViewportScroll,\n *   useTransform\n * } from \"framer\"\n *\n * export function MyComponent() {\n *   const { scrollYProgress } = useViewportScroll()\n *   return <Frame scaleX={scrollYProgress} />\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const { scrollYProgress } = useViewportScroll()\n *   return <motion.div style={{ scaleX: scrollYProgress }} />\n * }\n * ```\n *\n * @public\n */\nfunction useViewportScroll() {\n    /**\n     * Lazy-initialise the viewport scroll values\n     */\n    if (!viewportScrollValues) {\n        viewportScrollValues = createScrollMotionValues();\n    }\n    useIsomorphicLayoutEffect(function () {\n        !hasListeners && addEventListeners();\n    }, []);\n    return viewportScrollValues;\n}\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion;\nfunction initPrefersReducedMotion() {\n    prefersReducedMotion = motionValue(null);\n    if (typeof window === \"undefined\")\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return prefersReducedMotion.set(motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.set(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    !prefersReducedMotion && initPrefersReducedMotion();\n    var _a = tslib.__read(React.useState(prefersReducedMotion.get()), 2), shouldReduceMotion = _a[0], setShouldReduceMotion = _a[1];\n    useOnChange(prefersReducedMotion, setShouldReduceMotion);\n    return shouldReduceMotion;\n}\n\n/**\n * @public\n */\nfunction animationControls() {\n    /**\n     * Track whether the host component has mounted.\n     */\n    var hasMounted = false;\n    /**\n     * Pending animations that are started before a component is mounted.\n     * TODO: Remove this as animations should only run in effects\n     */\n    var pendingAnimations = [];\n    /**\n     * A collection of linked component animation controls.\n     */\n    var subscribers = new Set();\n    var controls = {\n        subscribe: function (visualElement) {\n            subscribers.add(visualElement);\n            return function () { return void subscribers.delete(visualElement); };\n        },\n        start: function (definition, transitionOverride) {\n            /**\n             * TODO: We only perform this hasMounted check because in Framer we used to\n             * encourage the ability to start an animation within the render phase. This\n             * isn't behaviour concurrent-safe so when we make Framer concurrent-safe\n             * we can ditch this.\n             */\n            if (hasMounted) {\n                var animations_1 = [];\n                subscribers.forEach(function (visualElement) {\n                    animations_1.push(animateVisualElement(visualElement, definition, {\n                        transitionOverride: transitionOverride,\n                    }));\n                });\n                return Promise.all(animations_1);\n            }\n            else {\n                return new Promise(function (resolve) {\n                    pendingAnimations.push({\n                        animation: [definition, transitionOverride],\n                        resolve: resolve,\n                    });\n                });\n            }\n        },\n        set: function (definition) {\n            heyListen.invariant(hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            return subscribers.forEach(function (visualElement) {\n                setValues(visualElement, definition);\n            });\n        },\n        stop: function () {\n            subscribers.forEach(function (visualElement) {\n                stopAnimation(visualElement);\n            });\n        },\n        mount: function () {\n            hasMounted = true;\n            pendingAnimations.forEach(function (_a) {\n                var animation = _a.animation, resolve = _a.resolve;\n                controls.start.apply(controls, tslib.__spreadArray([], tslib.__read(animation))).then(resolve);\n            });\n            return function () {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\n/**\n * Creates `AnimationControls`, which can be used to manually start, stop\n * and sequence animations on one or more components.\n *\n * The returned `AnimationControls` should be passed to the `animate` property\n * of the components you want to animate.\n *\n * These components can then be animated with the `start` method.\n *\n * @library\n *\n * ```jsx\n * import * as React from 'react'\n * import { Frame, useAnimation } from 'framer'\n *\n * export function MyComponent(props) {\n *    const controls = useAnimation()\n *\n *    controls.start({\n *        x: 100,\n *        transition: { duration: 0.5 },\n *    })\n *\n *    return <Frame animate={controls} />\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * import * as React from 'react'\n * import { motion, useAnimation } from 'framer-motion'\n *\n * export function MyComponent(props) {\n *    const controls = useAnimation()\n *\n *    controls.start({\n *        x: 100,\n *        transition: { duration: 0.5 },\n *    })\n *\n *    return <motion.div animate={controls} />\n * }\n * ```\n *\n * @returns Animation controller with `start` and `stop` methods\n *\n * @public\n */\nfunction useAnimation() {\n    var controls = useConstant(animationControls);\n    React.useEffect(controls.mount, []);\n    return controls;\n}\n\n/**\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\n *\n * @library\n *\n * ```jsx\n * import * as React from \"react\"\n * import { Frame, useCycle } from \"framer\"\n *\n * export function MyComponent() {\n *   const [x, cycleX] = useCycle(0, 50, 100)\n *\n *   return (\n *     <Frame\n *       animate={{ x: x }}\n *       onTap={() => cycleX()}\n *      />\n *    )\n * }\n * ```\n *\n * @motion\n *\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\n *\n * ```jsx\n * import * as React from \"react\"\n * import { motion, useCycle } from \"framer-motion\"\n *\n * export const MyComponent = () => {\n *   const [x, cycleX] = useCycle(0, 50, 100)\n *\n *   return (\n *     <motion.div\n *       animate={{ x: x }}\n *       onTap={() => cycleX()}\n *      />\n *    )\n * }\n * ```\n *\n * @param items - items to cycle through\n * @returns [currentState, cycleState]\n *\n * @public\n */\nfunction useCycle() {\n    var items = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        items[_i] = arguments[_i];\n    }\n    var index = React.useRef(0);\n    var _a = tslib.__read(React.useState(items[index.current]), 2), item = _a[0], setItem = _a[1];\n    return [\n        item,\n        function (next) {\n            index.current =\n                typeof next !== \"number\"\n                    ? popmotion.wrap(0, items.length, index.current + 1)\n                    : next;\n            setItem(items[index.current]);\n        },\n    ];\n}\n\n/**\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\n *\n * @library\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <Frame onTapStart={startDrag} />\n *     <Frame drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @motion\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nvar DragControls = /** @class */ (function () {\n    function DragControls() {\n        this.componentControls = new Set();\n    }\n    /**\n     * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.\n     *\n     * @internal\n     */\n    DragControls.prototype.subscribe = function (controls) {\n        var _this = this;\n        this.componentControls.add(controls);\n        return function () { return _this.componentControls.delete(controls); };\n    };\n    /**\n     * Start a drag gesture on every `motion` component that has this set of drag controls\n     * passed into it via the `dragControls` prop.\n     *\n     * ```jsx\n     * dragControls.start(e, {\n     *   snapToCursor: true\n     * })\n     * ```\n     *\n     * @param event - PointerEvent\n     * @param options - Options\n     *\n     * @public\n     */\n    DragControls.prototype.start = function (event, options) {\n        this.componentControls.forEach(function (controls) {\n            controls.start(event.nativeEvent || event, options);\n        });\n    };\n    DragControls.prototype.updateConstraints = function (flush) {\n        if (flush === void 0) { flush = true; }\n        this.componentControls.forEach(function (controls) {\n            controls.updateConstraints();\n        });\n        flush && flushLayout();\n    };\n    return DragControls;\n}());\nvar createDragControls = function () { return new DragControls(); };\n/**\n * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop\n * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we\n * might want to initiate that dragging from a different component than the draggable one.\n *\n * By creating a `dragControls` using the `useDragControls` hook, we can pass this into\n * the draggable component's `dragControls` prop. It exposes a `start` method\n * that can start dragging from pointer events on other components.\n *\n * @library\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <Frame onTapStart={startDrag} />\n *     <Frame drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @motion\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nfunction useDragControls() {\n    return useConstant(createDragControls);\n}\n\nvar createObject = function () { return ({}); };\nvar stateVisualElement = visualElement({\n    build: function () { },\n    measureViewportBox: axisBox,\n    resetTransform: function () { },\n    restoreTransform: function () { },\n    removeValueFromRenderState: function () { },\n    render: function () { },\n    scrapeMotionValuesFromProps: createObject,\n    readValueFromInstance: function (_state, key, options) {\n        return options.initialState[key] || 0;\n    },\n    makeTargetAnimatable: function (element, _a) {\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = tslib.__rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        checkTargetForNewValues(element, target, origin);\n        return tslib.__assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n});\nvar useVisualState = makeUseVisualState({\n    scrapeMotionValuesFromProps: createObject,\n    createRenderState: createObject,\n});\n/**\n * This is not an officially supported API and may be removed\n * on any version.\n * @internal\n */\nfunction useAnimatedState(initialState) {\n    var _a = tslib.__read(React.useState(initialState), 2), animationState = _a[0], setAnimationState = _a[1];\n    var visualState = useVisualState({}, false);\n    var element = useConstant(function () {\n        return stateVisualElement({ props: {}, visualState: visualState }, { initialState: initialState });\n    });\n    React.useEffect(function () {\n        element.mount({});\n        return element.unmount();\n    }, []);\n    React.useEffect(function () {\n        element.setProps({\n            onUpdate: function (v) { return setAnimationState(tslib.__assign({}, v)); },\n        });\n    });\n    var startAnimation = useConstant(function () { return function (animationDefinition) {\n        return animateVisualElement(element, animationDefinition);\n    }; });\n    return [animationState, startAnimation];\n}\n\n// Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\nvar maxScale = 100000;\nvar invertScale = function (scale) {\n    return scale > 0.001 ? 1 / scale : maxScale;\n};\nvar hasWarned = false;\n/**\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\n * of their respective parent scales.\n *\n * This is useful for undoing the distortion of content when scaling a parent component.\n *\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\n * of those instead.\n *\n * @motion\n *\n * ```jsx\n * const MyComponent = () => {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <motion.div style={{ scaleX, scaleY }} />\n * }\n * ```\n *\n * @library\n *\n * ```jsx\n * function MyComponent() {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <Frame scaleX={scaleX} scaleY={scaleY} />\n * }\n * ```\n *\n * @deprecated\n * @internal\n */\nfunction useInvertedScale(scale) {\n    var parentScaleX = useMotionValue(1);\n    var parentScaleY = useMotionValue(1);\n    var visualElement = useVisualElementContext();\n    heyListen.invariant(!!(scale || visualElement), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n    heyListen.warning(hasWarned, \"useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.\");\n    hasWarned = true;\n    if (scale) {\n        parentScaleX = scale.scaleX || parentScaleX;\n        parentScaleY = scale.scaleY || parentScaleY;\n    }\n    else if (visualElement) {\n        parentScaleX = visualElement.getValue(\"scaleX\", 1);\n        parentScaleY = visualElement.getValue(\"scaleY\", 1);\n    }\n    var scaleX = useTransform(parentScaleX, invertScale);\n    var scaleY = useTransform(parentScaleY, invertScale);\n    return { scaleX: scaleX, scaleY: scaleY };\n}\n\nexports.AnimatePresence = AnimatePresence;\nexports.AnimateSharedLayout = AnimateSharedLayout;\nexports.DragControls = DragControls;\nexports.FlatTree = FlatTree;\nexports.FramerTreeLayoutContext = FramerTreeLayoutContext;\nexports.LayoutGroupContext = LayoutGroupContext;\nexports.LazyMotion = LazyMotion;\nexports.MotionConfig = MotionConfig;\nexports.MotionConfigContext = MotionConfigContext;\nexports.MotionValue = MotionValue;\nexports.PresenceContext = PresenceContext;\nexports.SharedLayoutContext = SharedLayoutContext;\nexports.addScaleCorrection = addScaleCorrection;\nexports.animate = animate;\nexports.animateVisualElement = animateVisualElement;\nexports.animationControls = animationControls;\nexports.batchLayout = batchLayout;\nexports.createBatcher = createBatcher;\nexports.createCrossfader = createCrossfader;\nexports.createDomMotionComponent = createDomMotionComponent;\nexports.createMotionComponent = createMotionComponent;\nexports.domAnimation = domAnimation;\nexports.domMax = domMax;\nexports.flushLayout = flushLayout;\nexports.isValidMotionProp = isValidMotionProp;\nexports.m = m;\nexports.motion = motion;\nexports.motionValue = motionValue;\nexports.resolveMotionValue = resolveMotionValue;\nexports.snapshotViewportBox = snapshotViewportBox;\nexports.transform = transform;\nexports.useAnimation = useAnimation;\nexports.useCycle = useCycle;\nexports.useDeprecatedAnimatedState = useAnimatedState;\nexports.useDeprecatedInvertedScale = useInvertedScale;\nexports.useDomEvent = useDomEvent;\nexports.useDragControls = useDragControls;\nexports.useElementScroll = useElementScroll;\nexports.useIsPresent = useIsPresent;\nexports.useMotionTemplate = useMotionTemplate;\nexports.useMotionValue = useMotionValue;\nexports.usePresence = usePresence;\nexports.useReducedMotion = useReducedMotion;\nexports.useSpring = useSpring;\nexports.useTransform = useTransform;\nexports.useVelocity = useVelocity;\nexports.useViewportScroll = useViewportScroll;\nexports.visualElement = visualElement;\n","\"use strict\";\n(self[\"webpackChunk_N_E\"] = self[\"webpackChunk_N_E\"] || []).push([[6319],{\n\n/***/ 89141:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n\nvar tslib = __webpack_require__(70655);\nvar React = __webpack_require__(67294);\nvar heyListen = __webpack_require__(24394);\nvar styleValueTypes = __webpack_require__(83573);\nvar popmotion = __webpack_require__(39294);\nvar sync = __webpack_require__(84839);\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        Object.keys(e).forEach(function (k) {\n            if (k !== 'default') {\n                var d = Object.getOwnPropertyDescriptor(e, k);\n                Object.defineProperty(n, k, d.get ? d : {\n                    enumerable: true,\n                    get: function () {\n                        return e[k];\n                    }\n                });\n            }\n        });\n    }\n    n['default'] = e;\n    return Object.freeze(n);\n}\n\nvar React__namespace = /*#__PURE__*/_interopNamespace(React);\nvar React__default = /*#__PURE__*/_interopDefaultLegacy(React);\nvar sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);\n\nvar createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\n        \"layout\",\n        \"layoutId\",\n        \"drag\",\n        \"_layoutResetTransform\",\n    ]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\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    layoutAnimation: createDefinition([\"layout\", \"layoutId\"]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        var Component = features[key];\n        if (Component !== null)\n            featureDefinitions[key].Component = Component;\n    }\n}\n\nvar LazyContext = React.createContext({ strict: false });\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 = React.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 (false) {}\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__namespace.createElement(Component, tslib.__assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\n/**\n * @public\n */\nvar MotionConfigContext = React.createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n});\n\nvar MotionContext = React.createContext({});\nfunction useVisualElementContext() {\n    return React.useContext(MotionContext).visualElement;\n}\n\n/**\n * @public\n */\nvar PresenceContext = React.createContext(null);\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 = React.useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\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 = React.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 useOpaqueId when released in React\n    var id = useUniqueId();\n    React.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(React.useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useUniqueId = function () { return useConstant(incrementId); };\n\n/**\n * @internal\n */\nvar LayoutGroupContext = React.createContext(null);\n\nvar isBrowser = typeof window !== \"undefined\";\n\nvar useIsomorphicLayoutEffect = isBrowser ? React.useLayoutEffect : React.useEffect;\n\nfunction useLayoutId(_a) {\n    var layoutId = _a.layoutId;\n    var layoutGroupId = React.useContext(LayoutGroupContext);\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var config = React.useContext(MotionConfigContext);\n    var lazyContext = React.useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = React.useContext(PresenceContext);\n    var layoutId = useLayoutId(props);\n    var visualElementRef = React.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: tslib.__assign(tslib.__assign({}, props), { layoutId: layoutId }),\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        if (!visualElement)\n            return;\n        visualElement.setProps(tslib.__assign(tslib.__assign(tslib.__assign({}, config), props), { layoutId: layoutId }));\n        visualElement.isPresent = isPresent(presenceContext);\n        visualElement.isPresenceRoot =\n            !parent || parent.presenceId !== (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id);\n        /**\n         * Fire a render to ensure the latest state is reflected on-screen.\n         */\n        visualElement.syncRender();\n    });\n    React.useEffect(function () {\n        var _a;\n        if (!visualElement)\n            return;\n        /**\n         * In a future refactor we can replace the features-as-components and\n         * have this loop through them all firing \"effect\" listeners\n         */\n        (_a = 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\nfunction isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\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 React.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\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$1(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    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    return typeof definition === \"function\"\n        ? definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity)\n        : 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$1(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\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\nfunction useCreateMotionContext(props, isStatic) {\n    var _a = getCurrentTreeVariants(props, React.useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return React.useMemo(function () { return ({ initial: initial, animate: animate }); }, \n    /**\n     * Only break memoisation in static mode\n     */\n    isStatic\n        ? [\n            variantLabelsAsDependency(initial),\n            variantLabelsAsDependency(animate),\n        ]\n        : []);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\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 *\n * @internal\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\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 isStatic = React.useContext(MotionConfigContext).isStatic;\n        var features = null;\n        /**\n         * Create the tree context. This is memoized and will only trigger renders\n         * when the current tree variant changes in static mode.\n         */\n        var context = useCreateMotionContext(props, isStatic);\n        /**\n         *\n         */\n        var visualState = useVisualState(props, isStatic);\n        if (!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, props, createVisualElement);\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             * TODO: The intention is to move these away from a React-centric to a\n             * VisualElement-centric lifecycle scheme.\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__namespace.createElement(React__namespace.Fragment, null,\n            React__namespace.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic)),\n            features));\n    }\n    return React.forwardRef(MotionComponent);\n}\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    /**\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\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\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\nvar valueScaleCorrection = {};\n/**\n * @internal\n */\nfunction addScaleCorrection(correctors) {\n    for (var key in correctors) {\n        valueScaleCorrection[key] = correctors[key];\n    }\n}\n\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\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!valueScaleCorrection[key] || key === \"opacity\")));\n}\n\nvar isMotionValue = function (value) {\n    return value !== null && typeof value === \"object\" && value.getVelocity;\n};\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 += (translateAlias[key] || key) + \"(\" + 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 originX + \" \" + originY + \" \" + originZ;\n}\n\n/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable$1(key) {\n    return key.startsWith(\"--\");\n}\n\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\nvar int = tslib.__assign(tslib.__assign({}, styleValueTypes.number), { transform: Math.round });\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: styleValueTypes.px,\n    borderTopWidth: styleValueTypes.px,\n    borderRightWidth: styleValueTypes.px,\n    borderBottomWidth: styleValueTypes.px,\n    borderLeftWidth: styleValueTypes.px,\n    borderRadius: styleValueTypes.px,\n    radius: styleValueTypes.px,\n    borderTopLeftRadius: styleValueTypes.px,\n    borderTopRightRadius: styleValueTypes.px,\n    borderBottomRightRadius: styleValueTypes.px,\n    borderBottomLeftRadius: styleValueTypes.px,\n    // Positioning props\n    width: styleValueTypes.px,\n    maxWidth: styleValueTypes.px,\n    height: styleValueTypes.px,\n    maxHeight: styleValueTypes.px,\n    size: styleValueTypes.px,\n    top: styleValueTypes.px,\n    right: styleValueTypes.px,\n    bottom: styleValueTypes.px,\n    left: styleValueTypes.px,\n    // Spacing props\n    padding: styleValueTypes.px,\n    paddingTop: styleValueTypes.px,\n    paddingRight: styleValueTypes.px,\n    paddingBottom: styleValueTypes.px,\n    paddingLeft: styleValueTypes.px,\n    margin: styleValueTypes.px,\n    marginTop: styleValueTypes.px,\n    marginRight: styleValueTypes.px,\n    marginBottom: styleValueTypes.px,\n    marginLeft: styleValueTypes.px,\n    // Transform props\n    rotate: styleValueTypes.degrees,\n    rotateX: styleValueTypes.degrees,\n    rotateY: styleValueTypes.degrees,\n    rotateZ: styleValueTypes.degrees,\n    scale: styleValueTypes.scale,\n    scaleX: styleValueTypes.scale,\n    scaleY: styleValueTypes.scale,\n    scaleZ: styleValueTypes.scale,\n    skew: styleValueTypes.degrees,\n    skewX: styleValueTypes.degrees,\n    skewY: styleValueTypes.degrees,\n    distance: styleValueTypes.px,\n    translateX: styleValueTypes.px,\n    translateY: styleValueTypes.px,\n    translateZ: styleValueTypes.px,\n    x: styleValueTypes.px,\n    y: styleValueTypes.px,\n    z: styleValueTypes.px,\n    perspective: styleValueTypes.px,\n    transformPerspective: styleValueTypes.px,\n    opacity: styleValueTypes.alpha,\n    originX: styleValueTypes.progressPercentage,\n    originY: styleValueTypes.progressPercentage,\n    originZ: styleValueTypes.px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: styleValueTypes.alpha,\n    strokeOpacity: styleValueTypes.alpha,\n    numOctaves: int,\n};\n\nfunction buildHTMLStyles(state, latestValues, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin) {\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$1(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            /**\n             * If layout projection is on, and we need to perform scale correction for this\n             * value type, perform it.\n             */\n            if ((projection === null || projection === void 0 ? void 0 : projection.isHydrated) &&\n                (layoutState === null || layoutState === void 0 ? void 0 : layoutState.isHydrated) &&\n                valueScaleCorrection[key]) {\n                var correctedValue = valueScaleCorrection[key].process(value, layoutState, projection);\n                /**\n                 * Scale-correctable values can define a number of other values to break\n                 * down into. For instance borderRadius needs applying to borderBottomLeftRadius etc\n                 */\n                var applyTo = valueScaleCorrection[key].applyTo;\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        style[applyTo[i]] = correctedValue;\n                    }\n                }\n                else {\n                    style[key] = correctedValue;\n                }\n            }\n            else {\n                style[key] = valueAsType;\n            }\n        }\n    }\n    if (layoutState &&\n        projection &&\n        buildProjectionTransform &&\n        buildProjectionTransformOrigin) {\n        style.transform = buildProjectionTransform(layoutState.deltaFinal, layoutState.treeScale, hasTransform ? transform : undefined);\n        if (transformTemplate) {\n            style.transform = transformTemplate(transform, style.transform);\n        }\n        style.transformOrigin = buildProjectionTransformOrigin(layoutState);\n    }\n    else {\n        if (hasTransform) {\n            style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n        }\n        if (hasTransformOrigin) {\n            style.transformOrigin = buildTransformOrigin(transformOrigin);\n        }\n    }\n}\n\nvar createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\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 React.useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, undefined, undefined, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return tslib.__assign(tslib.__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)) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect = style.WebkitUserSelect = style.WebkitTouchCallout =\n            \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\" + (props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\n/**\n * A list of all valid MotionProps.\n *\n * @internalremarks\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    \"_layoutResetTransform\",\n    \"onLayoutAnimationComplete\",\n    \"onViewportBoxUpdate\",\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    \"_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]);\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\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\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    var emotionIsPropValid_1 = (__webpack_require__(78208)/* [\"default\"] */ .Z);\n    shouldForward = function (key) {\n        // Handle events explicitly as Emotion validates them all as true\n        if (key.startsWith(\"on\")) {\n            return !isValidMotionProp(key);\n        }\n        else {\n            return emotionIsPropValid_1(key);\n        }\n    };\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            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nfunction calcOrigin$1(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : styleValueTypes.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$1(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin$1(originY, dimensions.y, dimensions.height);\n    return pxOriginX + \" \" + pxOriginY;\n}\n\n// Convert a progress 0-1 to a pixels value based on the provided length\nvar progressToPixels = function (progress, length) {\n    return styleValueTypes.px.transform(progress * length);\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, totalLength, 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    // 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] = progressToPixels(-offset, totalLength);\n    // Build the dash array\n    var pathLength = progressToPixels(length, totalLength);\n    var pathSpacing = progressToPixels(spacing, totalLength);\n    attrs[keys.array] = pathLength + \" \" + pathSpacing;\n}\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin) {\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 = tslib.__rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions, totalPathLength = state.totalPathLength;\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 measured\n    if (totalPathLength !== undefined && pathLength !== undefined) {\n        buildSVGPath(attrs, totalPathLength, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nvar createSvgRenderState = function () { return (tslib.__assign(tslib.__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = React.useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, undefined, undefined, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return tslib.__assign(tslib.__assign({}, state.attrs), { style: tslib.__assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = tslib.__assign(tslib.__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, 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 = tslib.__assign(tslib.__assign(tslib.__assign({}, filteredProps), visualProps), { ref: ref });\n        return React.createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nvar 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\nfunction renderHTML(element, _a) {\n    var style = _a.style, vars = _a.vars;\n    // Directly assign style into the Element's style prop. In tests Object.assign is the\n    // fastest way to assign styles.\n    Object.assign(element.style, style);\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\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]);\n\nfunction renderSVG(element, renderState) {\n    renderHTML(element, renderState);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nfunction scrapeMotionValuesFromProps$1(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\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\nfunction isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nvar isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\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\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 *\n * @internal\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\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) { return function (props, isStatic) {\n    var context = React.useContext(MotionContext);\n    var presenceContext = React.useContext(PresenceContext);\n    return isStatic\n        ? makeState(config, props, context, presenceContext)\n        : useConstant(function () { return makeState(config, props, context, presenceContext); });\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 variantToSet = blockInitialAnimation || initial === false ? 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 = tslib.__rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target)\n                values[key] = target[key];\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\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            if (isPath(instance)) {\n                renderState.totalPathLength = instance.getTotalLength();\n            }\n            buildSVGAttrs(renderState, latestValues, undefined, undefined, { enableHardwareAcceleration: false }, props.transformTemplate);\n            // TODO: Replace with direct assignment\n            renderSVG(instance, renderState);\n        },\n    }),\n};\nfunction isPath(element) {\n    return element.tagName === \"path\";\n}\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return tslib.__assign(tslib.__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement,\n        Component: Component });\n}\n\nvar 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[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nfunction addDomEvent(target, eventName, handler, options) {\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler, options); };\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    React.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\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\nfunction 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\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}\nfunction getViewportPointFromEvent(event) {\n    return extractEventInfo(event, \"client\");\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\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\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\nfunction 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\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\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);\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined);\n}\n\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\nfunction useUnmountEffect(callback) {\n    return React.useEffect(function () { return function () { return callback(); }; }, []);\n}\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 = React.useRef(false);\n    var cancelPointerEndListeners = React.useRef(null);\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 = popmotion.pipe(addPointerEvent(window, \"pointerup\", onPointerUp), addPointerEvent(window, \"pointercancel\", onPointerCancel));\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined);\n    useUnmountEffect(removePointerEndListener);\n}\n\nvar makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nvar gestureAnimations = {\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nfunction 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\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\nvar easingLookup = {\n    linear: popmotion.linear,\n    easeIn: popmotion.easeIn,\n    easeInOut: popmotion.easeInOut,\n    easeOut: popmotion.easeOut,\n    circIn: popmotion.circIn,\n    circInOut: popmotion.circInOut,\n    circOut: popmotion.circOut,\n    backIn: popmotion.backIn,\n    backInOut: popmotion.backInOut,\n    backOut: popmotion.backOut,\n    anticipate: popmotion.anticipate,\n    bounceIn: popmotion.bounceIn,\n    bounceInOut: popmotion.bounceInOut,\n    bounceOut: popmotion.bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        heyListen.invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = tslib.__read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return popmotion.cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        heyListen.invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\" + 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\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        styleValueTypes.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\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\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    restDelta: 0.01,\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 tslib.__assign({ to: to }, transitionFactory(to));\n};\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = tslib.__assign(tslib.__assign({}, numberValueTypes), { \n    // Color props\n    color: styleValueTypes.color, backgroundColor: styleValueTypes.color, outlineColor: styleValueTypes.color, fill: styleValueTypes.color, stroke: styleValueTypes.color, \n    // Border props\n    borderColor: styleValueTypes.color, borderTopColor: styleValueTypes.color, borderRightColor: styleValueTypes.color, borderBottomColor: styleValueTypes.color, borderLeftColor: styleValueTypes.color, filter: styleValueTypes.filter, WebkitFilter: styleValueTypes.filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== styleValueTypes.filter)\n        defaultValueType = styleValueTypes.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\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 = tslib.__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 = tslib.__rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = tslib.__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        heyListen.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;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = tslib.__spreadArray([], tslib.__read(options.to));\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 = tslib.__assign(tslib.__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return tslib.__assign(tslib.__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    heyListen.warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \" + key + \" from \\\"\" + origin + \"\\\" to \\\"\" + target + \"\\\". \" + origin + \" is not an animatable value - to enable this animation set \" + origin + \" to a value animatable to \" + 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            ? popmotion.inertia(tslib.__assign(tslib.__assign({}, options), valueTransition))\n            : popmotion.animate(tslib.__assign(tslib.__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;\n        value.set(target);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.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 *\n * @internal\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\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 = 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\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\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\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\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         * 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 = sync.getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync__default['default'].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__default['default'].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     * @library\n     *\n     * ```jsx\n     * function 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 <Frame x={x} />\n     * }\n     * ```\n     *\n     * @motion\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     * @internalremarks\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                popmotion.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}());\n/**\n * @internal\n */\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\n/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\n/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [styleValueTypes.number, styleValueTypes.px, styleValueTypes.percent, styleValueTypes.degrees, styleValueTypes.vw, styleValueTypes.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\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(dimensionValueTypes)), [styleValueTypes.color, styleValueTypes.complex]);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\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\n        ? visualElement.makeTargetAnimatable(resolved, false)\n        : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = tslib.__rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = tslib.__assign(tslib.__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 = tslib.__spreadArray([], tslib.__read(variantLabels)).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\" && isNumericalString(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) && styleValueTypes.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\n/**\n * @internal\n */\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart();\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 = tslib.__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 = tslib.__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 animation = startAnimation(key, value, valueTarget, tslib.__assign({ delay: delay }, transition));\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, tslib.__assign(tslib.__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\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Focus,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = tslib.__spreadArray([], tslib.__read(variantPriorityOrder)).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 = tslib.__rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = tslib.__assign(tslib.__assign(tslib.__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 = tslib.__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 shouldAnimateType = variantsHaveChanged(typeState.prevProp, prop) ||\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 = tslib.__assign(tslib.__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)) {\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 = tslib.__assign(tslib.__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, tslib.__spreadArray([], tslib.__read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: tslib.__assign({ type: type }, options),\n                }); }))));\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 = tslib.__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        return animateChanges(options, type);\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction variantsHaveChanged(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.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\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            React.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 = tslib.__read(usePresence(), 2), isPresent = _a[0], onExitComplete = _a[1];\n        var presenceContext = React.useContext(PresenceContext);\n        React.useEffect(function () {\n            var _a, _b;\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(onExitComplete));\n        }, [isPresent]);\n    }),\n};\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 = popmotion.distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = sync.getFrameData().timestamp;\n            _this.history.push(tslib.__assign(tslib.__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__default['default'].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 = sync.getFrameData().timestamp;\n        this.history = [tslib.__assign(tslib.__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = popmotion.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        sync.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\nfunction noop(any) {\n    return any;\n}\n\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 convertBoundingBoxToAxisBox(_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 convertAxisBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return {\n        top: y.min,\n        bottom: y.max,\n        left: x.min,\n        right: x.max,\n    };\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 transformBoundingBox(_a, transformPoint) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    if (transformPoint === void 0) { transformPoint = noop; }\n    var topLeft = transformPoint({ x: left, y: top });\n    var bottomRight = transformPoint({ x: right, y: bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n/**\n * Create an empty axis box of zero size\n */\nfunction axisBox() {\n    return { x: { min: 0, max: 1 }, y: { min: 0, max: 1 } };\n}\nfunction copyAxisBox(box) {\n    return {\n        x: tslib.__assign({}, box.x),\n        y: tslib.__assign({}, box.y),\n    };\n}\n/**\n * Create an empty box delta\n */\nvar zeroDelta = {\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n};\nfunction delta() {\n    return {\n        x: tslib.__assign({}, zeroDelta),\n        y: tslib.__assign({}, zeroDelta),\n    };\n}\n\n// Call a handler once for each axis\nfunction eachAxis(handler) {\n    return [handler(\"x\"), handler(\"y\")];\n}\n\nvar clampProgress = function (v) { return popmotion.clamp(0, 1, v); };\n/**\n * Returns true if the provided value is within maxDistance of the provided target\n */\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return popmotion.distance(value, target) < maxDistance;\n}\nfunction calcLength(axis) {\n    return axis.max - axis.min;\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 = popmotion.progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = popmotion.progress(source.min, source.max - targetLength, target.min);\n    }\n    return clampProgress(origin);\n}\n/**\n * Update the AxisDelta with a transform that projects source into target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = popmotion.mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001))\n        delta.scale = 1;\n    delta.translate =\n        popmotion.mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate))\n        delta.translate = 0;\n}\n/**\n * Update the BoxDelta with a transform that projects the source into the target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateBoxDelta(delta, source, target, origin) {\n    updateAxisDelta(delta.x, source.x, target.x, defaultOrigin(origin.originX));\n    updateAxisDelta(delta.y, source.y, target.y, defaultOrigin(origin.originY));\n}\n/**\n * Currently this only accepts numerical origins, measured as 0-1, but could\n * accept pixel values by comparing to the target axis.\n */\nfunction defaultOrigin(origin) {\n    return typeof origin === \"number\" ? origin : 0.5;\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(projection, parentProjection) {\n    calcRelativeAxis(projection.target.x, projection.relativeTarget.x, parentProjection.target.x);\n    calcRelativeAxis(projection.target.y, projection.relativeTarget.y, parentProjection.target.y);\n}\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 ? popmotion.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 ? popmotion.mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculates a min projection point based on a pointer, pointer progress\n * within the drag target, and constraints.\n *\n * For instance if an element was 100px width, we were dragging from 0.25\n * along this axis, the pointer is at 200px, and there were no constraints,\n * we would calculate a min projection point of 175px.\n */\nfunction calcConstrainedMinPoint(point, length, progress, constraints, elastic) {\n    // Calculate a min point for this axis and apply it to the current pointer\n    var min = point - length * progress;\n    return constraints ? applyConstraints(min, constraints, elastic) : min;\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 = tslib.__read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return {\n        min: layoutAxis.min + min,\n        max: layoutAxis.min + max,\n    };\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 the an axis position based on two axes and a progress value.\n */\nfunction calcPositionFromProgress(axis, constraints, progress) {\n    var axisLength = axis.max - axis.min;\n    var min = popmotion.mix(constraints.min, constraints.max - axisLength, progress);\n    return { min: min, max: min + axisLength };\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 === 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\n/**\n * Measure and return the element bounding box.\n *\n * We convert the box into an AxisBox2D to make it easier to work with each axis\n * individually and programmatically.\n *\n * This function optionally accepts a transformPagePoint function which allows us to compensate\n * for, for instance, measuring the element within a scaled plane like a Framer devivce preview component.\n */\nfunction getBoundingBox(element, transformPagePoint) {\n    var box = element.getBoundingClientRect();\n    return convertBoundingBoxToAxisBox(transformBoundingBox(box, transformPagePoint));\n}\n\nvar compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nfunction isProjecting(visualElement) {\n    var isEnabled = visualElement.projection.isEnabled;\n    return isEnabled || visualElement.shouldResetTransform();\n}\nfunction collectProjectingAncestors(visualElement, ancestors) {\n    if (ancestors === void 0) { ancestors = []; }\n    var parent = visualElement.parent;\n    if (parent)\n        collectProjectingAncestors(parent, ancestors);\n    if (isProjecting(visualElement))\n        ancestors.push(visualElement);\n    return ancestors;\n}\nfunction collectProjectingChildren(visualElement) {\n    var children = [];\n    var addChild = function (child) {\n        if (isProjecting(child))\n            children.push(child);\n        child.children.forEach(addChild);\n    };\n    visualElement.children.forEach(addChild);\n    return children.sort(compareByDepth);\n}\n/**\n * Update the layoutState by measuring the DOM layout. This\n * should be called after resetting any layout-affecting transforms.\n */\nfunction updateLayoutMeasurement(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    var layoutState = visualElement.getLayoutState();\n    visualElement.notifyBeforeLayoutMeasure(layoutState.layout);\n    layoutState.isHydrated = true;\n    layoutState.layout = visualElement.measureViewportBox();\n    layoutState.layoutCorrected = copyAxisBox(layoutState.layout);\n    visualElement.notifyLayoutMeasure(layoutState.layout, visualElement.prevViewportBox || layoutState.layout);\n    sync__default['default'].update(function () { return visualElement.rebaseProjectionTarget(); });\n}\n/**\n * Record the viewport box as it was before an expected mutation/re-render\n */\nfunction snapshotViewportBox(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    visualElement.prevViewportBox = visualElement.measureViewportBox(false);\n    /**\n     * Update targetBox to match the prevViewportBox. This is just to ensure\n     * that targetBox is affected by scroll in the same way as the measured box\n     */\n    visualElement.rebaseProjectionTarget(false, visualElement.prevViewportBox);\n}\n\nfunction tweenAxis(target, prev, next, p) {\n    target.min = popmotion.mix(prev.min, next.min, p);\n    target.max = popmotion.mix(prev.max, next.max, p);\n}\nfunction calcRelativeOffsetAxis(parent, child) {\n    return {\n        min: child.min - parent.min,\n        max: child.max - parent.min,\n    };\n}\nfunction calcRelativeOffset(parent, child) {\n    return {\n        x: calcRelativeOffsetAxis(parent.x, child.x),\n        y: calcRelativeOffsetAxis(parent.y, child.y),\n    };\n}\nfunction checkIfParentHasChanged(prev, next) {\n    var prevId = prev.getLayoutId();\n    var nextId = next.getLayoutId();\n    return prevId !== nextId || (nextId === undefined && prev !== next);\n}\n\nfunction isDraggable(visualElement) {\n    var _a = visualElement.getProps(), drag = _a.drag, _dragX = _a._dragX;\n    return drag && !_dragX;\n}\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction resetAxis(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 resetBox(box, originBox) {\n    resetAxis(box.x, originBox.x);\n    resetAxis(box.y, originBox.y);\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 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 applyAxisTransforms(final, axis, transforms, _a) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    // Copy the current axis to the final axis before mutation\n    final.min = axis.min;\n    final.max = axis.max;\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = popmotion.mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(final, 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 applyBoxTransforms(finalBox, box, transforms) {\n    applyAxisTransforms(finalBox.x, box.x, transforms, xKeys);\n    applyAxisTransforms(finalBox.y, box.y, transforms, yKeys);\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) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    var originPoint = popmotion.mix(axis.min, axis.max, origin) - 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) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale);\n}\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) {\n    removeAxisTransforms(box.x, transforms, xKeys);\n    removeAxisTransforms(box.y, transforms, yKeys);\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) {\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.getLayoutState().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        // If this is a draggable ancestor, also incorporate the node's transform to the layout box\n        if (isDraggable(node)) {\n            applyBoxTransforms(box, box, node.getLatestValues());\n        }\n    }\n}\n\n/**\n * Returns a boolean stating whether or not we converted the projection\n * to relative projection.\n */\nfunction convertToRelativeProjection(visualElement, isLayoutDrag) {\n    if (isLayoutDrag === void 0) { isLayoutDrag = true; }\n    var projectionParent = visualElement.getProjectionParent();\n    if (!projectionParent)\n        return false;\n    var offset;\n    if (isLayoutDrag) {\n        offset = calcRelativeOffset(projectionParent.projection.target, visualElement.projection.target);\n        removeBoxTransforms(offset, projectionParent.getLatestValues());\n    }\n    else {\n        offset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n    }\n    eachAxis(function (axis) {\n        return visualElement.setProjectionTargetAxis(axis, offset[axis].min, offset[axis].max, true);\n    });\n    return true;\n}\n\nvar unresolvedJobs = new Set();\nfunction pushJob(stack, job, pointer) {\n    if (!stack[pointer])\n        stack[pointer] = [];\n    stack[pointer].push(job);\n}\nfunction batchLayout(callback) {\n    unresolvedJobs.add(callback);\n    return function () { return unresolvedJobs.delete(callback); };\n}\nfunction flushLayout() {\n    if (!unresolvedJobs.size)\n        return;\n    var pointer = 0;\n    var reads = [[]];\n    var writes = [];\n    var setRead = function (job) { return pushJob(reads, job, pointer); };\n    var setWrite = function (job) {\n        pushJob(writes, job, pointer);\n        pointer++;\n    };\n    /**\n     * Resolve jobs into their array stacks\n     */\n    unresolvedJobs.forEach(function (callback) {\n        callback(setRead, setWrite);\n        pointer = 0;\n    });\n    unresolvedJobs.clear();\n    /**\n     * Execute jobs\n     */\n    var numStacks = writes.length;\n    for (var i = 0; i <= numStacks; i++) {\n        reads[i] && reads[i].forEach(executeJob);\n        writes[i] && writes[i].forEach(executeJob);\n    }\n}\nvar executeJob = function (job) { return job(); };\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\nvar lastPointerEvent;\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(_a) {\n        var visualElement = _a.visualElement;\n        /**\n         * Track whether we're currently dragging.\n         *\n         * @internal\n         */\n        this.isDragging = false;\n        /**\n         * The current direction of drag, or `null` if both.\n         *\n         * @internal\n         */\n        this.currentDirection = null;\n        /**\n         * The permitted boundaries of travel, in pixels.\n         *\n         * @internal\n         */\n        this.constraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         *\n         * @internal\n         */\n        this.elastic = axisBox();\n        /**\n         * A reference to the host component's latest props.\n         *\n         * @internal\n         */\n        this.props = {};\n        /**\n         * @internal\n         */\n        this.hasMutatedConstraints = false;\n        /**\n         * Track the initial position of the cursor relative to the dragging element\n         * when dragging starts as a value of 0-1 on each axis. We then use this to calculate\n         * an ideal bounding box for the VisualElement renderer to project into every frame.\n         *\n         * @internal\n         */\n        this.cursorProgress = {\n            x: 0.5,\n            y: 0.5,\n        };\n        // When updating _dragX, or _dragY instead of the VisualElement,\n        // persist their values between drag gestures.\n        this.originPoint = {};\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        /**\n         * @internal\n         */\n        this.panSession = null;\n        this.visualElement = visualElement;\n        this.visualElement.enableLayoutProjection();\n        elementDragControls.set(visualElement, this);\n    }\n    /**\n     * Instantiate a PanSession for the drag gesture\n     *\n     * @public\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, cursorProgress = _b.cursorProgress;\n        var onSessionStart = function (event) {\n            var _a;\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopMotion();\n            /**\n             * Save the initial point. We'll use this to calculate the pointer's position rather\n             * than the one we receive when the gesture actually starts. By then, the pointer will\n             * have already moved, and the perception will be of the pointer \"slipping\" across the element\n             */\n            var initialPoint = getViewportPointFromEvent(event).point;\n            (_a = _this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(_this);\n            _this.cancelLayout = batchLayout(function (read, write) {\n                var ancestors = collectProjectingAncestors(_this.visualElement);\n                var children = collectProjectingChildren(_this.visualElement);\n                var tree = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(ancestors)), tslib.__read(children));\n                var hasManuallySetCursorOrigin = false;\n                /**\n                 * Apply a simple lock to the projection target. This ensures no animations\n                 * can run on the projection box while this lock is active.\n                 */\n                _this.isLayoutDrag() && _this.visualElement.lockProjectionTarget();\n                write(function () {\n                    tree.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    updateLayoutMeasurement(_this.visualElement);\n                    children.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    tree.forEach(function (element) { return element.restoreTransform(); });\n                    if (snapToCursor) {\n                        hasManuallySetCursorOrigin = _this.snapToCursor(initialPoint);\n                    }\n                });\n                read(function () {\n                    var isRelativeDrag = Boolean(_this.getAxisMotionValue(\"x\") && !_this.isExternalDrag());\n                    if (!isRelativeDrag) {\n                        _this.visualElement.rebaseProjectionTarget(true, _this.visualElement.measureViewportBox(false));\n                    }\n                    _this.visualElement.scheduleUpdateLayoutProjection();\n                    /**\n                     * When dragging starts, we want to find where the cursor is relative to the bounding box\n                     * of the element. Every frame, we calculate a new bounding box using this relative position\n                     * and let the visualElement renderer figure out how to reproject the element into this bounding\n                     * box.\n                     *\n                     * By doing it this way, rather than applying an x/y transform directly to the element,\n                     * we can ensure the component always visually sticks to the cursor as we'd expect, even\n                     * if the DOM element itself changes layout as a result of React updates the user might\n                     * make based on the drag position.\n                     */\n                    var projection = _this.visualElement.projection;\n                    eachAxis(function (axis) {\n                        if (!hasManuallySetCursorOrigin) {\n                            var _a = projection.target[axis], min = _a.min, max = _a.max;\n                            _this.cursorProgress[axis] = cursorProgress\n                                ? cursorProgress[axis]\n                                : popmotion.progress(min, max, initialPoint[axis]);\n                        }\n                        /**\n                         * If we have external drag MotionValues, record their origin point. On pointermove\n                         * we'll apply the pan gesture offset directly to this value.\n                         */\n                        var axisValue = _this.getAxisMotionValue(axis);\n                        if (axisValue) {\n                            _this.originPoint[axis] = axisValue.get();\n                        }\n                    });\n                });\n                write(function () {\n                    sync.flushSync.update();\n                    sync.flushSync.preRender();\n                    sync.flushSync.render();\n                    sync.flushSync.postRender();\n                });\n                read(function () { return _this.resolveDragConstraints(); });\n            });\n        };\n        var onStart = function (event, info) {\n            var _a, _b, _c;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _d = _this.props, drag = _d.drag, dragPropagation = _d.dragPropagation;\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            flushLayout();\n            // Set current drag status\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            // Fire onDragStart event\n            (_b = (_a = _this.props).onDragStart) === null || _b === void 0 ? void 0 : _b.call(_a, event, info);\n            (_c = _this.visualElement.animationState) === null || _c === void 0 ? void 0 : _c.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            var _a, _b, _c, _d;\n            var _e = _this.props, dragPropagation = _e.dragPropagation, dragDirectionLock = _e.dragDirectionLock;\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                    (_b = (_a = _this.props).onDirectionLock) === null || _b === void 0 ? void 0 : _b.call(_a, _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            // Fire onDrag event\n            (_d = (_c = _this.props).onDrag) === null || _d === void 0 ? void 0 : _d.call(_c, event, info);\n            // Update the last pointer event\n            lastPointerEvent = event;\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        var transformPagePoint = this.props.transformPagePoint;\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: transformPagePoint });\n    };\n    VisualElementDragControls.prototype.resolveDragConstraints = function () {\n        var _this = this;\n        var _a = this.props, dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = this.visualElement.getLayoutState().layoutCorrected;\n        if (dragConstraints) {\n            this.constraints = isRefObject(dragConstraints)\n                ? this.resolveRefConstraints(layout, dragConstraints)\n                : calcRelativeConstraints(layout, dragConstraints);\n        }\n        else {\n            this.constraints = false;\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 (this.constraints && !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function (layoutBox, constraints) {\n        var _a = this.props, onMeasureDragConstraints = _a.onMeasureDragConstraints, transformPagePoint = _a.transformPagePoint;\n        var constraintsElement = constraints.current;\n        heyListen.invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        this.constraintsBox = getBoundingBox(constraintsElement, transformPagePoint);\n        var measuredConstraints = calcViewportConstraints(layoutBox, this.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(convertAxisBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToAxisBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.cancelDrag = function () {\n        var _a, _b;\n        this.visualElement.unlockProjectionTarget();\n        (_a = this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(this);\n        this.isDragging = false;\n        this.panSession && this.panSession.end();\n        this.panSession = null;\n        if (!this.props.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.stop = function (event, info) {\n        var _a, _b, _c;\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = null;\n        var isDragging = this.isDragging;\n        this.cancelDrag();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.animateDragEnd(velocity);\n        (_c = (_b = this.props).onDragEnd) === null || _c === void 0 ? void 0 : _c.call(_b, event, info);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        return eachAxis(function (axis) {\n            var drag = _this.props.drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var box = _this.visualElement.getLayoutState().layout;\n                var length_1 = box[axis].max - box[axis].min;\n                var center = box[axis].min + length_1 / 2;\n                var offset = point[axis] - center;\n                _this.originPoint[axis] = point[axis];\n                axisValue.set(offset);\n            }\n            else {\n                _this.cursorProgress[axis] = 0.5;\n                return true;\n            }\n        }).includes(true);\n    };\n    /**\n     * Update the specified axis with the latest pointer information.\n     */\n    VisualElementDragControls.prototype.updateAxis = function (axis, point, offset) {\n        var drag = this.props.drag;\n        // If we're not dragging this axis, do an early return.\n        if (!shouldDrag(axis, drag, this.currentDirection))\n            return;\n        return this.getAxisMotionValue(axis)\n            ? this.updateAxisMotionValue(axis, offset)\n            : this.updateVisualElementAxis(axis, point);\n    };\n    VisualElementDragControls.prototype.updateAxisMotionValue = function (axis, offset) {\n        var axisValue = this.getAxisMotionValue(axis);\n        if (!offset || !axisValue)\n            return;\n        var nextValue = this.originPoint[axis] + offset[axis];\n        var update = this.constraints\n            ? applyConstraints(nextValue, this.constraints[axis], this.elastic[axis])\n            : nextValue;\n        axisValue.set(update);\n    };\n    VisualElementDragControls.prototype.updateVisualElementAxis = function (axis, point) {\n        var _a;\n        // Get the actual layout bounding box of the element\n        var axisLayout = this.visualElement.getLayoutState().layout[axis];\n        // Calculate its current length. In the future we might want to lerp this to animate\n        // between lengths if the layout changes as we change the DOM\n        var axisLength = axisLayout.max - axisLayout.min;\n        // Get the initial progress that the pointer sat on this axis on gesture start.\n        var axisProgress = this.cursorProgress[axis];\n        // Calculate a new min point based on the latest pointer position, constraints and elastic\n        var min = calcConstrainedMinPoint(point[axis], axisLength, axisProgress, (_a = this.constraints) === null || _a === void 0 ? void 0 : _a[axis], this.elastic[axis]);\n        // Update the axis viewport target with this new min and the length\n        this.visualElement.setProjectionTargetAxis(axis, min, min + axisLength);\n    };\n    VisualElementDragControls.prototype.setProps = function (_a) {\n        var _b = _a.drag, drag = _b === void 0 ? false : _b, _c = _a.dragDirectionLock, dragDirectionLock = _c === void 0 ? false : _c, _d = _a.dragPropagation, dragPropagation = _d === void 0 ? false : _d, _e = _a.dragConstraints, dragConstraints = _e === void 0 ? false : _e, _f = _a.dragElastic, dragElastic = _f === void 0 ? defaultElastic : _f, _g = _a.dragMomentum, dragMomentum = _g === void 0 ? true : _g, remainingProps = tslib.__rest(_a, [\"drag\", \"dragDirectionLock\", \"dragPropagation\", \"dragConstraints\", \"dragElastic\", \"dragMomentum\"]);\n        this.props = tslib.__assign({ drag: drag,\n            dragDirectionLock: dragDirectionLock,\n            dragPropagation: dragPropagation,\n            dragConstraints: dragConstraints,\n            dragElastic: dragElastic,\n            dragMomentum: dragMomentum }, remainingProps);\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     * - If the component will perform layout animations, we output the gesture to the component's\n     *      visual bounding box\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a = this.props, layout = _a.layout, layoutId = _a.layoutId;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        if (this.props[dragKey]) {\n            return this.props[dragKey];\n        }\n        else if (!layout && layoutId === undefined) {\n            return this.visualElement.getValue(axis, 0);\n        }\n    };\n    VisualElementDragControls.prototype.isLayoutDrag = function () {\n        return !this.getAxisMotionValue(\"x\");\n    };\n    VisualElementDragControls.prototype.isExternalDrag = function () {\n        var _a = this.props, _dragX = _a._dragX, _dragY = _a._dragY;\n        return _dragX || _dragY;\n    };\n    VisualElementDragControls.prototype.animateDragEnd = function (velocity) {\n        var _this = this;\n        var _a = this.props, drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition;\n        /**\n         * Everything beyond the drag gesture should be performed with\n         * relative projection so children stay in sync with their parent element.\n         */\n        var isRelative = convertToRelativeProjection(this.visualElement, this.isLayoutDrag() && !this.isExternalDrag());\n        /**\n         * If we had previously resolved constraints relative to the viewport,\n         * we need to also convert those to a relative coordinate space for the animation\n         */\n        var constraints = this.constraints || {};\n        if (isRelative &&\n            Object.keys(constraints).length &&\n            this.isLayoutDrag()) {\n            var projectionParent = this.visualElement.getProjectionParent();\n            if (projectionParent) {\n                var relativeConstraints_1 = calcRelativeOffset(projectionParent.projection.targetFinal, constraints);\n                eachAxis(function (axis) {\n                    var _a = relativeConstraints_1[axis], min = _a.min, max = _a.max;\n                    constraints[axis] = {\n                        min: isNaN(min) ? undefined : min,\n                        max: isNaN(max) ? undefined : max,\n                    };\n                });\n            }\n        }\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            /**\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 = tslib.__assign(tslib.__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness,\n                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.getAxisMotionValue(axis)\n                ? _this.startAxisValueAnimation(axis, inertia)\n                : _this.visualElement.startLayoutAnimation(axis, inertia, isRelative);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(function () {\n            var _a, _b;\n            (_b = (_a = _this.props).onDragTransitionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);\n        });\n    };\n    VisualElementDragControls.prototype.stopMotion = function () {\n        var _this = this;\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            axisValue\n                ? axisValue.stop()\n                : _this.visualElement.stopLayoutAnimation();\n        });\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        if (!axisValue)\n            return;\n        var currentValue = axisValue.get();\n        axisValue.set(currentValue);\n        axisValue.set(currentValue); // Set twice to hard-reset velocity\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.scalePoint = function () {\n        var _this = this;\n        var _a = this.props, drag = _a.drag, dragConstraints = _a.dragConstraints;\n        if (!isRefObject(dragConstraints) || !this.constraintsBox)\n            return;\n        // Stop any current animations as there can be some visual glitching if we resize mid animation\n        this.stopMotion();\n        // Record the relative progress of the targetBox relative to the constraintsBox\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            boxProgress[axis] = calcOrigin(_this.visualElement.projection.target[axis], _this.constraintsBox[axis]);\n        });\n        /**\n         * For each axis, calculate the current progress of the layout axis within the constraints.\n         * Then, using the latest layout and constraints measurements, reposition the new layout axis\n         * proportionally within the constraints.\n         */\n        this.updateConstraints(function () {\n            eachAxis(function (axis) {\n                if (!shouldDrag(axis, drag, null))\n                    return;\n                // Calculate the position of the targetBox relative to the constraintsBox using the\n                // previously calculated progress\n                var _a = calcPositionFromProgress(_this.visualElement.projection.target[axis], _this.constraintsBox[axis], boxProgress[axis]), min = _a.min, max = _a.max;\n                _this.visualElement.setProjectionTargetAxis(axis, min, max);\n            });\n        });\n        /**\n         * If any other draggable components are queuing the same tasks synchronously\n         * this will wait until they've all been scheduled before flushing.\n         */\n        setTimeout(flushLayout, 1);\n    };\n    VisualElementDragControls.prototype.updateConstraints = function (onReady) {\n        var _this = this;\n        this.cancelLayout = batchLayout(function (read, write) {\n            var ancestors = collectProjectingAncestors(_this.visualElement);\n            write(function () {\n                return ancestors.forEach(function (element) { return element.resetTransform(); });\n            });\n            read(function () { return updateLayoutMeasurement(_this.visualElement); });\n            write(function () {\n                return ancestors.forEach(function (element) { return element.restoreTransform(); });\n            });\n            read(function () {\n                _this.resolveDragConstraints();\n            });\n            if (onReady)\n                write(onReady);\n        });\n    };\n    VisualElementDragControls.prototype.mount = function (visualElement) {\n        var _this = this;\n        var element = 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.props, drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\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            _this.scalePoint();\n        });\n        /**\n         * Ensure drag constraints are resolved correctly relative to the dragging element\n         * whenever its layout changes.\n         */\n        var stopLayoutUpdateListener = visualElement.onLayoutUpdate(function () {\n            if (_this.isDragging) {\n                _this.resolveDragConstraints();\n            }\n        });\n        /**\n         * If the previous component with this same layoutId was dragging at the time\n         * it was unmounted, we want to continue the same gesture on this component.\n         */\n        var prevDragCursor = visualElement.prevDragCursor;\n        if (prevDragCursor) {\n            this.start(lastPointerEvent, { cursorProgress: prevDragCursor });\n        }\n        /**\n         * Return a function that will teardown the drag gesture\n         */\n        return function () {\n            stopPointerListener === null || stopPointerListener === void 0 ? void 0 : stopPointerListener();\n            stopResizeListener === null || stopResizeListener === void 0 ? void 0 : stopResizeListener();\n            stopLayoutUpdateListener === null || stopLayoutUpdateListener === void 0 ? void 0 : stopLayoutUpdateListener();\n            _this.cancelDrag();\n        };\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\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 transformPagePoint = React.useContext(MotionConfigContext).transformPagePoint;\n    var dragControls = useConstant(function () {\n        return new VisualElementDragControls({\n            visualElement: visualElement,\n        });\n    });\n    dragControls.setProps(tslib.__assign(tslib.__assign({}, props), { transformPagePoint: transformPagePoint }));\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    React.useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls]);\n    // Mount the drag controls with the visualElement\n    React.useEffect(function () { return dragControls.mount(visualElement); }, []);\n}\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @internalremarks\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 = React.useRef(null);\n    var transformPagePoint = React.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    React.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\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\n/**\n * @public\n */\nvar Presence;\n(function (Presence) {\n    Presence[Presence[\"Entering\"] = 0] = \"Entering\";\n    Presence[Presence[\"Present\"] = 1] = \"Present\";\n    Presence[Presence[\"Exiting\"] = 2] = \"Exiting\";\n})(Presence || (Presence = {}));\n/**\n * @public\n */\nexports.VisibilityAction = void 0;\n(function (VisibilityAction) {\n    VisibilityAction[VisibilityAction[\"Hide\"] = 0] = \"Hide\";\n    VisibilityAction[VisibilityAction[\"Show\"] = 1] = \"Show\";\n})(exports.VisibilityAction || (exports.VisibilityAction = {}));\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 = tslib.__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    heyListen.invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n    var _a = tslib.__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 = tslib.__rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof HTMLElement))\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 = tslib.__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\nfunction pixelsToPercent(pixels, axis) {\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 */\nfunction correctBorderRadius(latest, _layoutState, _a) {\n    var target = _a.target;\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 (styleValueTypes.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, target.x);\n    var y = pixelsToPercent(latest, target.y);\n    return x + \"% \" + y + \"%\";\n}\nvar varToken = \"_$css\";\nfunction correctBoxShadow(latest, _a) {\n    var delta = _a.delta, treeScale = _a.treeScale;\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 = styleValueTypes.complex.parse(latest);\n    // TODO: Doesn't support multiple shadows\n    if (shadow.length > 5)\n        return original;\n    var template = styleValueTypes.complex.createTransformer(latest);\n    var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n    // Calculate the overall context scale\n    var xScale = delta.x.scale * treeScale.x;\n    var yScale = delta.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 = popmotion.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}\nvar borderCorrectionDefinition = {\n    process: correctBorderRadius,\n};\nvar defaultScaleCorrectors = {\n    borderRadius: tslib.__assign(tslib.__assign({}, borderCorrectionDefinition), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: borderCorrectionDefinition,\n    borderTopRightRadius: borderCorrectionDefinition,\n    borderBottomLeftRadius: borderCorrectionDefinition,\n    borderBottomRightRadius: borderCorrectionDefinition,\n    boxShadow: {\n        process: correctBoxShadow,\n    },\n};\n\nvar progressTarget = 1000;\nvar Animate = /** @class */ (function (_super) {\n    tslib.__extends(Animate, _super);\n    function Animate() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /**\n         * A mutable object that tracks the target viewport box\n         * for the current animation frame.\n         */\n        _this.frameTarget = axisBox();\n        /**\n         * The current animation target, we use this to check whether to start\n         * a new animation or continue the existing one.\n         */\n        _this.currentAnimationTarget = axisBox();\n        /**\n         * Track whether we're animating this axis.\n         */\n        _this.isAnimating = {\n            x: false,\n            y: false,\n        };\n        _this.stopAxisAnimation = {\n            x: undefined,\n            y: undefined,\n        };\n        _this.isAnimatingTree = false;\n        _this.animate = function (target, origin, _a) {\n            if (_a === void 0) { _a = {}; }\n            var originBox = _a.originBox, targetBox = _a.targetBox, visibilityAction = _a.visibilityAction, shouldStackAnimate = _a.shouldStackAnimate, onComplete = _a.onComplete, prevParent = _a.prevParent, config = tslib.__rest(_a, [\"originBox\", \"targetBox\", \"visibilityAction\", \"shouldStackAnimate\", \"onComplete\", \"prevParent\"]);\n            var _b = _this.props, visualElement = _b.visualElement, layout = _b.layout;\n            /**\n             * Early return if we've been instructed not to animate this render.\n             */\n            if (shouldStackAnimate === false) {\n                _this.isAnimatingTree = false;\n                return _this.safeToRemove();\n            }\n            /**\n             * Prioritise tree animations\n             */\n            if (_this.isAnimatingTree && shouldStackAnimate !== true) {\n                return;\n            }\n            else if (shouldStackAnimate) {\n                _this.isAnimatingTree = true;\n            }\n            /**\n             * Allow the measured origin (prev bounding box) and target (actual layout) to be\n             * overridden by the provided config.\n             */\n            origin = originBox || origin;\n            target = targetBox || target;\n            /**\n             * If this element has a projecting parent, there's an opportunity to animate\n             * it relatively to that parent rather than relatively to the viewport. This\n             * allows us to add orchestrated animations.\n             */\n            var isRelative = false;\n            var projectionParent = visualElement.getProjectionParent();\n            if (projectionParent) {\n                var prevParentViewportBox = projectionParent.prevViewportBox;\n                var parentLayout = projectionParent.getLayoutState().layout;\n                /**\n                 * If we're being provided a previous parent VisualElement by AnimateSharedLayout\n                 */\n                if (prevParent) {\n                    /**\n                     * If we've been provided an explicit target box it means we're animating back\n                     * to this previous parent. So we can make a relative box by comparing to the previous\n                     * parent's layout\n                     */\n                    if (targetBox) {\n                        parentLayout = prevParent.getLayoutState().layout;\n                    }\n                    /**\n                     * Likewise if we've been provided an explicit origin box it means we're\n                     * animating out from a different element. So we should figure out where that was\n                     * on screen relative to the new parent element.\n                     */\n                    if (originBox &&\n                        !checkIfParentHasChanged(prevParent, projectionParent) &&\n                        prevParent.prevViewportBox) {\n                        prevParentViewportBox = prevParent.prevViewportBox;\n                    }\n                }\n                if (prevParentViewportBox &&\n                    isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox)) {\n                    isRelative = true;\n                    origin = calcRelativeOffset(prevParentViewportBox, origin);\n                    target = calcRelativeOffset(parentLayout, target);\n                }\n            }\n            var boxHasMoved = hasMoved(origin, target);\n            var animations = eachAxis(function (axis) {\n                var _a, _b;\n                /**\n                 * If layout is set to \"position\", we can resize the origin box based on the target\n                 * box and only animate its position.\n                 */\n                if (layout === \"position\") {\n                    var targetLength = target[axis].max - target[axis].min;\n                    origin[axis].max = origin[axis].min + targetLength;\n                }\n                if (visualElement.projection.isTargetLocked) {\n                    return;\n                }\n                else if (visibilityAction !== undefined) {\n                    visualElement.setVisibility(visibilityAction === exports.VisibilityAction.Show);\n                }\n                else if (boxHasMoved) {\n                    // If the box has moved, animate between it's current visual state and its\n                    // final state\n                    return _this.animateAxis(axis, target[axis], origin[axis], tslib.__assign(tslib.__assign({}, config), { isRelative: isRelative }));\n                }\n                else {\n                    (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a);\n                    // If the box has remained in the same place, immediately set the axis target\n                    // to the final desired state\n                    return visualElement.setProjectionTargetAxis(axis, target[axis].min, target[axis].max, isRelative);\n                }\n            });\n            // Force a render to ensure there's no flash of uncorrected bounding box.\n            visualElement.syncRender();\n            /**\n             * If this visualElement isn't present (ie it's been removed from the tree by the user but\n             * kept in by the tree by AnimatePresence) then call safeToRemove when all axis animations\n             * have successfully finished.\n             */\n            return Promise.all(animations).then(function () {\n                _this.isAnimatingTree = false;\n                onComplete && onComplete();\n                visualElement.notifyLayoutAnimationComplete();\n            });\n        };\n        return _this;\n    }\n    Animate.prototype.componentDidMount = function () {\n        var _this = this;\n        var visualElement = this.props.visualElement;\n        visualElement.animateMotionValue = startAnimation;\n        visualElement.enableLayoutProjection();\n        this.unsubLayoutReady = visualElement.onLayoutUpdate(this.animate);\n        visualElement.layoutSafeToRemove = function () { return _this.safeToRemove(); };\n        addScaleCorrection(defaultScaleCorrectors);\n    };\n    Animate.prototype.componentWillUnmount = function () {\n        var _this = this;\n        this.unsubLayoutReady();\n        eachAxis(function (axis) { var _a, _b; return (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a); });\n    };\n    /**\n     * TODO: This manually performs animations on the visualElement's layout progress\n     * values. It'd be preferable to amend the startLayoutAxisAnimation\n     * API to accept more custom animations like this.\n     */\n    Animate.prototype.animateAxis = function (axis, target, origin, _a) {\n        var _this = this;\n        var _b, _c;\n        var _d = _a === void 0 ? {} : _a, transition = _d.transition, isRelative = _d.isRelative;\n        /**\n         * If we're not animating to a new target, don't run this animation\n         */\n        if (this.isAnimating[axis] &&\n            axisIsEqual(target, this.currentAnimationTarget[axis])) {\n            return;\n        }\n        (_c = (_b = this.stopAxisAnimation)[axis]) === null || _c === void 0 ? void 0 : _c.call(_b);\n        this.isAnimating[axis] = true;\n        var visualElement = this.props.visualElement;\n        var frameTarget = this.frameTarget[axis];\n        var layoutProgress = visualElement.getProjectionAnimationProgress()[axis];\n        /**\n         * Set layout progress back to 0. We set it twice to hard-reset any velocity that might\n         * be re-incoporated into a subsequent spring animation.\n         */\n        layoutProgress.clearListeners();\n        layoutProgress.set(0);\n        layoutProgress.set(0);\n        /**\n         * Create an animation function to run once per frame. This will tween the visual bounding box from\n         * origin to target using the latest progress value.\n         */\n        var frame = function () {\n            // Convert the latest layoutProgress, which is a value from 0-1000, into a 0-1 progress\n            var p = layoutProgress.get() / progressTarget;\n            // Tween the axis and update the visualElement with the latest values\n            tweenAxis(frameTarget, origin, target, p);\n            visualElement.setProjectionTargetAxis(axis, frameTarget.min, frameTarget.max, isRelative);\n        };\n        // Synchronously run a frame to ensure there's no flash of the uncorrected bounding box.\n        frame();\n        // Create a function to stop animation on this specific axis\n        var unsubscribeProgress = layoutProgress.onChange(frame);\n        this.stopAxisAnimation[axis] = function () {\n            _this.isAnimating[axis] = false;\n            layoutProgress.stop();\n            unsubscribeProgress();\n        };\n        this.currentAnimationTarget[axis] = target;\n        var layoutTransition = transition ||\n            visualElement.getDefaultTransition() ||\n            defaultLayoutTransition;\n        // Start the animation on this axis\n        var animation = startAnimation(axis === \"x\" ? \"layoutX\" : \"layoutY\", layoutProgress, progressTarget, layoutTransition && getValueTransition(layoutTransition, \"layout\")).then(this.stopAxisAnimation[axis]);\n        return animation;\n    };\n    Animate.prototype.safeToRemove = function () {\n        var _a, _b;\n        (_b = (_a = this.props).safeToRemove) === null || _b === void 0 ? void 0 : _b.call(_a);\n    };\n    Animate.prototype.render = function () {\n        return null;\n    };\n    return Animate;\n}(React__namespace.Component));\nfunction AnimateLayoutContextProvider(props) {\n    var _a = tslib.__read(usePresence(), 2), safeToRemove = _a[1];\n    return React__namespace.createElement(Animate, tslib.__assign({}, props, { safeToRemove: safeToRemove }));\n}\nfunction hasMoved(a, b) {\n    return (!isZeroBox(a) &&\n        !isZeroBox(b) &&\n        (!axisIsEqual(a.x, b.x) || !axisIsEqual(a.y, b.y)));\n}\nvar zeroAxis = { min: 0, max: 0 };\nfunction isZeroBox(a) {\n    return axisIsEqual(a.x, zeroAxis) && axisIsEqual(a.y, zeroAxis);\n}\nfunction axisIsEqual(a, b) {\n    return a.min === b.min && a.max === b.max;\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox) {\n    return prevParent || (!prevParent && !(originBox || targetBox));\n}\n\n/**\n * Default handlers for batching VisualElements\n */\nvar defaultHandler = {\n    layoutReady: function (child) { return child.notifyLayoutReady(); },\n};\n/**\n * Create a batcher to process VisualElements\n */\nfunction createBatcher() {\n    var queue = new Set();\n    return {\n        add: function (child) { return queue.add(child); },\n        flush: function (_a) {\n            var _b = _a === void 0 ? defaultHandler : _a, layoutReady = _b.layoutReady, parent = _b.parent;\n            batchLayout(function (read, write) {\n                var order = Array.from(queue).sort(compareByDepth);\n                var ancestors = parent\n                    ? collectProjectingAncestors(parent)\n                    : [];\n                write(function () {\n                    var allElements = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(ancestors)), tslib.__read(order));\n                    allElements.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    order.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    ancestors.forEach(function (element) { return element.restoreTransform(); });\n                    order.forEach(layoutReady);\n                });\n                read(function () {\n                    /**\n                     * After all children have started animating, ensure any Entering components are set to Present.\n                     * If we add deferred animations (set up all animations and then start them in two loops) this\n                     * could be moved to the start loop. But it needs to happen after all the animations configs\n                     * are generated in AnimateSharedLayout as this relies on presence data\n                     */\n                    order.forEach(function (child) {\n                        if (child.isPresent)\n                            child.presence = Presence.Present;\n                    });\n                });\n                write(function () {\n                    /**\n                     * Starting these animations will have queued jobs on the frame loop. In some situations,\n                     * like when removing an element, these will be processed too late after the DOM is manipulated,\n                     * leaving a flash of incorrectly-projected content. By manually flushing these jobs\n                     * we ensure there's no flash.\n                     */\n                    sync.flushSync.preRender();\n                    sync.flushSync.render();\n                });\n                read(function () {\n                    /**\n                     * Schedule a callback at the end of the following frame to assign the latest projection\n                     * box to the prevViewportBox snapshot. Once global batching is in place this could be run\n                     * synchronously. But for now it ensures that if any nested `AnimateSharedLayout` top-level\n                     * child attempts to calculate its previous relative position against a prevViewportBox\n                     * it will be against its latest projection box instead, as the snapshot is useless beyond this\n                     * render.\n                     */\n                    sync__default['default'].postRender(function () {\n                        return order.forEach(assignProjectionToSnapshot);\n                    });\n                    queue.clear();\n                });\n            });\n            // TODO: Need to find a layout-synchronous way of flushing this\n            flushLayout();\n        },\n    };\n}\nfunction assignProjectionToSnapshot(child) {\n    child.prevViewportBox = child.projection.target;\n}\n\nvar SharedLayoutContext = React.createContext(createBatcher());\n/**\n * @internal\n */\nvar FramerTreeLayoutContext = React.createContext(createBatcher());\nfunction isSharedLayout(context) {\n    return !!context.forceUpdate;\n}\n\n/**\n * This component is responsible for scheduling the measuring of the motion component\n */\nvar Measure = /** @class */ (function (_super) {\n    tslib.__extends(Measure, _super);\n    function Measure() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * If this is a child of a SyncContext, register the VisualElement with it on mount.\n     */\n    Measure.prototype.componentDidMount = function () {\n        var _a = this.props, syncLayout = _a.syncLayout, framerSyncLayout = _a.framerSyncLayout, visualElement = _a.visualElement;\n        isSharedLayout(syncLayout) && syncLayout.register(visualElement);\n        isSharedLayout(framerSyncLayout) &&\n            framerSyncLayout.register(visualElement);\n        visualElement.onUnmount(function () {\n            if (isSharedLayout(syncLayout)) {\n                syncLayout.remove(visualElement);\n            }\n            if (isSharedLayout(framerSyncLayout)) {\n                framerSyncLayout.remove(visualElement);\n            }\n        });\n    };\n    /**\n     * If this is a child of a SyncContext, notify it that it needs to re-render. It will then\n     * handle the snapshotting.\n     *\n     * If it is stand-alone component, add it to the batcher.\n     */\n    Measure.prototype.getSnapshotBeforeUpdate = function () {\n        var _a = this.props, syncLayout = _a.syncLayout, visualElement = _a.visualElement;\n        if (isSharedLayout(syncLayout)) {\n            syncLayout.syncUpdate();\n        }\n        else {\n            snapshotViewportBox(visualElement);\n            syncLayout.add(visualElement);\n        }\n        return null;\n    };\n    Measure.prototype.componentDidUpdate = function () {\n        var syncLayout = this.props.syncLayout;\n        if (!isSharedLayout(syncLayout))\n            syncLayout.flush();\n    };\n    Measure.prototype.render = function () {\n        return null;\n    };\n    return Measure;\n}(React__default['default'].Component));\nfunction MeasureContextProvider(props) {\n    var syncLayout = React.useContext(SharedLayoutContext);\n    var framerSyncLayout = React.useContext(FramerTreeLayoutContext);\n    return (React__default['default'].createElement(Measure, tslib.__assign({}, props, { syncLayout: syncLayout, framerSyncLayout: framerSyncLayout })));\n}\n\nvar layoutAnimations = {\n    measureLayout: MeasureContextProvider,\n    layoutAnimation: AnimateLayoutContextProvider,\n};\n\nvar createProjectionState = function () { return ({\n    isEnabled: false,\n    isHydrated: false,\n    isTargetLocked: false,\n    target: axisBox(),\n    targetFinal: axisBox(),\n}); };\nfunction createLayoutState() {\n    return {\n        isHydrated: false,\n        layout: axisBox(),\n        layoutCorrected: axisBox(),\n        treeScale: { x: 1, y: 1 },\n        delta: delta(),\n        deltaFinal: delta(),\n        deltaTransform: \"\",\n    };\n}\nvar zeroLayout = createLayoutState();\n\n/**\n * Build a transform style that takes a calculated delta between the element's current\n * space on screen and projects it into the desired space.\n */\nfunction buildLayoutProjectionTransform(_a, treeScale, latestTransform) {\n    var x = _a.x, y = _a.y;\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 = x.translate / treeScale.x;\n    var yTranslate = y.translate / treeScale.y;\n    var transform = \"translate3d(\" + xTranslate + \"px, \" + yTranslate + \"px, 0) \";\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\" + rotate + \") \";\n        if (rotateX)\n            transform += \"rotateX(\" + rotateX + \") \";\n        if (rotateY)\n            transform += \"rotateY(\" + rotateY + \") \";\n    }\n    transform += \"scale(\" + x.scale + \", \" + y.scale + \")\";\n    return !latestTransform && transform === identityProjection ? \"\" : transform;\n}\n/**\n * Take the calculated delta origin and apply it as a transform string.\n */\nfunction buildLayoutProjectionTransformOrigin(_a) {\n    var deltaFinal = _a.deltaFinal;\n    return deltaFinal.x.origin * 100 + \"% \" + deltaFinal.y.origin * 100 + \"% 0\";\n}\nvar identityProjection = buildLayoutProjectionTransform(zeroLayout.delta, zeroLayout.treeScale, { x: 1, y: 1 });\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\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            return names.forEach(function (name) {\n                var _a;\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                var on = \"on\" + name;\n                var propListener = props[on];\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, tslib.__spreadArray([], tslib.__read(args)));\n        };\n    });\n    return lifecycles;\n}\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        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\nfunction updateLayoutDeltas(_a, _b, treePath, transformOrigin) {\n    var delta = _a.delta, layout = _a.layout, layoutCorrected = _a.layoutCorrected, treeScale = _a.treeScale;\n    var target = _b.target;\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    resetBox(layoutCorrected, layout);\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(layoutCorrected, treeScale, treePath);\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    updateBoxDelta(delta, layoutCorrected, target, transformOrigin);\n}\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\nfunction setCurrentViewportBox(visualElement) {\n    var projectionParent = visualElement.getProjectionParent();\n    if (!projectionParent) {\n        visualElement.rebaseProjectionTarget();\n        return;\n    }\n    var relativeOffset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n    eachAxis(function (axis) {\n        visualElement.setProjectionTargetAxis(axis, relativeOffset[axis].min, relativeOffset[axis].max, true);\n    });\n}\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, resetTransform = _a.resetTransform, restoreTransform = _a.restoreTransform, 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;\n        if (options === void 0) { options = {}; }\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 and onViewportBoxUpdate.\n         */\n        var lifecycles = createLifecycles();\n        /**\n         *\n         */\n        var projection = createProjectionState();\n        /**\n         * A reference to the nearest projecting parent. This is either\n         * undefined if we haven't looked for the nearest projecting parent,\n         * false if there is no parent performing layout projection, or a reference\n         * to the projecting parent.\n         */\n        var projectionParent;\n        /**\n         * This is a reference to the visual state of the \"lead\" visual element.\n         * Usually, this will be this visual element. But if it shares a layoutId\n         * with other visual elements, only one of them will be designated lead by\n         * AnimateSharedLayout. All the other visual elements will take on the visual\n         * appearance of the lead while they crossfade to it.\n         */\n        var leadProjection = projection;\n        var leadLatestValues = latestValues;\n        var unsubscribeFromLeadVisualElement;\n        /**\n         * The latest layout measurements and calculated projections. This\n         * is seperate from the target projection data in visualState as\n         * many visual elements might point to the same piece of visualState as\n         * a target, whereas they might each have different layouts and thus\n         * projection calculations needed to project into the same viewport box.\n         */\n        var layoutState = createLayoutState();\n        /**\n         *\n         */\n        var crossfader;\n        /**\n         * Keep track of whether the viewport box has been updated since the\n         * last time the layout projection was re-calculated.\n         */\n        var hasViewportBoxUpdated = false;\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         * x/y motion values that track the progress of initiated layout\n         * animations.\n         *\n         * TODO: Target for removal\n         */\n        var projectionTargetProgress;\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 = tslib.__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         *\n         */\n        function render() {\n            if (!instance)\n                return;\n            if (element.isProjectionReady()) {\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                applyBoxTransforms(leadProjection.targetFinal, leadProjection.target, leadLatestValues);\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                updateBoxDelta(layoutState.deltaFinal, layoutState.layoutCorrected, leadProjection.targetFinal, latestValues);\n            }\n            triggerBuild();\n            renderInstance(instance, renderState);\n        }\n        function triggerBuild() {\n            var valuesToRender = latestValues;\n            if (crossfader && crossfader.isActive()) {\n                var crossfadedValues = crossfader.getCrossfadeState(element);\n                if (crossfadedValues)\n                    valuesToRender = crossfadedValues;\n            }\n            build(element, renderState, valuesToRender, leadProjection, layoutState, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        function updateLayoutProjection() {\n            if (!element.isProjectionReady())\n                return;\n            var delta = layoutState.delta, treeScale = layoutState.treeScale;\n            var prevTreeScaleX = treeScale.x;\n            var prevTreeScaleY = treeScale.y;\n            var prevDeltaTransform = layoutState.deltaTransform;\n            updateLayoutDeltas(layoutState, leadProjection, element.path, latestValues);\n            hasViewportBoxUpdated &&\n                element.notifyViewportBoxUpdate(leadProjection.target, delta);\n            hasViewportBoxUpdated = false;\n            var deltaTransform = buildLayoutProjectionTransform(delta, treeScale);\n            if (deltaTransform !== prevDeltaTransform ||\n                // Also compare calculated treeScale, for values that rely on this only for scale correction\n                prevTreeScaleX !== treeScale.x ||\n                prevTreeScaleY !== treeScale.y) {\n                element.scheduleRender();\n            }\n            layoutState.deltaTransform = deltaTransform;\n        }\n        function updateTreeLayoutProjection() {\n            element.layoutTree.forEach(fireUpdateLayoutProjection);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync__default['default'].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 = tslib.__assign(tslib.__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             * An ancestor path back to the root visual element. This is used\n             * by layout projection to quickly recurse back up the tree.\n             */\n            path: parent ? tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(parent.path)), [parent]) : [], layoutTree: parent ? parent.layoutTree : new FlatTree(), \n            /**\n             *\n             */\n            presenceId: presenceId,\n            projection: projection, \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 AnimateSharedLayout, 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                instance = element.current = newInstance;\n                element.pointTo(element);\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n            },\n            /**\n             *\n             */\n            unmount: function () {\n                sync.cancelSync.update(update);\n                sync.cancelSync.render(render);\n                sync.cancelSync.preRender(element.updateLayoutProjection);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                element.stopLayoutAnimation();\n                element.layoutTree.remove(element);\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n                lifecycles.clearAllListeners();\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 () { 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             * A method that schedules an update to layout projections throughout\n             * the tree. We inherit from the parent so there's only ever one\n             * job scheduled on the next frame - that of the root visual element.\n             */\n            scheduleUpdateLayoutProjection: parent\n                ? parent.scheduleUpdateLayoutProjection\n                : function () {\n                    return sync__default['default'].preRender(element.updateTreeLayoutProjection, false, true);\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            // 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) { var _a; return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options); }, \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__default['default'].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                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; }, \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            // Layout projection ==============================\n            /**\n             * Enable layout projection for this visual element. Won't actually\n             * occur until we also have hydrated layout measurements.\n             */\n            enableLayoutProjection: function () {\n                projection.isEnabled = true;\n                element.layoutTree.add(element);\n            },\n            /**\n             * Lock the projection target, for instance when dragging, so\n             * nothing else can try and animate it.\n             */\n            lockProjectionTarget: function () {\n                projection.isTargetLocked = true;\n            },\n            unlockProjectionTarget: function () {\n                element.stopLayoutAnimation();\n                projection.isTargetLocked = false;\n            }, getLayoutState: function () { return layoutState; }, setCrossfader: function (newCrossfader) {\n                crossfader = newCrossfader;\n            }, isProjectionReady: function () {\n                return projection.isEnabled &&\n                    projection.isHydrated &&\n                    layoutState.isHydrated;\n            }, \n            /**\n             * Start a layout animation on a given axis.\n             */\n            startLayoutAnimation: function (axis, transition, isRelative) {\n                if (isRelative === void 0) { isRelative = false; }\n                var progress = element.getProjectionAnimationProgress()[axis];\n                var _a = isRelative\n                    ? projection.relativeTarget[axis]\n                    : projection.target[axis], min = _a.min, max = _a.max;\n                var length = max - min;\n                progress.clearListeners();\n                progress.set(min);\n                progress.set(min); // Set twice to hard-reset velocity\n                progress.onChange(function (v) {\n                    element.setProjectionTargetAxis(axis, v, v + length, isRelative);\n                });\n                return element.animateMotionValue(axis, progress, 0, transition);\n            },\n            /**\n             * Stop layout animations.\n             */\n            stopLayoutAnimation: function () {\n                eachAxis(function (axis) {\n                    return element.getProjectionAnimationProgress()[axis].stop();\n                });\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 (withTransform) {\n                if (withTransform === void 0) { withTransform = true; }\n                var viewportBox = measureViewportBox(instance, options);\n                if (!withTransform)\n                    removeBoxTransforms(viewportBox, latestValues);\n                return viewportBox;\n            },\n            /**\n             * Get the motion values tracking the layout animations on each\n             * axis. Lazy init if not already created.\n             */\n            getProjectionAnimationProgress: function () {\n                projectionTargetProgress || (projectionTargetProgress = {\n                    x: motionValue(0),\n                    y: motionValue(0),\n                });\n                return projectionTargetProgress;\n            },\n            /**\n             * Update the projection of a single axis. Schedule an update to\n             * the tree layout projection.\n             */\n            setProjectionTargetAxis: function (axis, min, max, isRelative) {\n                if (isRelative === void 0) { isRelative = false; }\n                var target;\n                if (isRelative) {\n                    if (!projection.relativeTarget) {\n                        projection.relativeTarget = axisBox();\n                    }\n                    target = projection.relativeTarget[axis];\n                }\n                else {\n                    projection.relativeTarget = undefined;\n                    target = projection.target[axis];\n                }\n                projection.isHydrated = true;\n                target.min = min;\n                target.max = max;\n                // Flag that we want to fire the onViewportBoxUpdate event handler\n                hasViewportBoxUpdated = true;\n                lifecycles.notifySetAxisTarget();\n            },\n            /**\n             * Rebase the projection target on top of the provided viewport box\n             * or the measured layout. This ensures that non-animating elements\n             * don't fall out of sync differences in measurements vs projections\n             * after a page scroll or other relayout.\n             */\n            rebaseProjectionTarget: function (force, box) {\n                if (box === void 0) { box = layoutState.layout; }\n                var _a = element.getProjectionAnimationProgress(), x = _a.x, y = _a.y;\n                var shouldRebase = !projection.relativeTarget &&\n                    !projection.isTargetLocked &&\n                    !x.isAnimating() &&\n                    !y.isAnimating();\n                if (force || shouldRebase) {\n                    eachAxis(function (axis) {\n                        var _a = box[axis], min = _a.min, max = _a.max;\n                        element.setProjectionTargetAxis(axis, min, max);\n                    });\n                }\n            },\n            /**\n             * Notify the visual element that its layout is up-to-date.\n             * Currently Animate.tsx uses this to check whether a layout animation\n             * needs to be performed.\n             */\n            notifyLayoutReady: function (config) {\n                setCurrentViewportBox(element);\n                element.notifyLayoutUpdate(layoutState.layout, element.prevViewportBox || layoutState.layout, config);\n            }, \n            /**\n             * Temporarily reset the transform of the instance.\n             */\n            resetTransform: function () { return resetTransform(element, instance, props); }, restoreTransform: function () { return restoreTransform(instance, renderState); }, updateLayoutProjection: updateLayoutProjection,\n            updateTreeLayoutProjection: function () {\n                element.layoutTree.forEach(fireResolveRelativeTargetBox);\n                /**\n                 * Schedule the projection updates at the end of the current preRender\n                 * step. This will ensure that all layout trees will first resolve\n                 * relative projection boxes into viewport boxes, and *then*\n                 * update projections.\n                 */\n                sync__default['default'].preRender(updateTreeLayoutProjection, false, true);\n                // sync.postRender(() => element.scheduleUpdateLayoutProjection())\n            },\n            getProjectionParent: function () {\n                if (projectionParent === undefined) {\n                    var foundParent = false;\n                    // Search backwards through the tree path\n                    for (var i = element.path.length - 1; i >= 0; i--) {\n                        var ancestor = element.path[i];\n                        if (ancestor.projection.isEnabled) {\n                            foundParent = ancestor;\n                            break;\n                        }\n                    }\n                    projectionParent = foundParent;\n                }\n                return projectionParent;\n            },\n            resolveRelativeTargetBox: function () {\n                var relativeParent = element.getProjectionParent();\n                if (!projection.relativeTarget || !relativeParent)\n                    return;\n                calcRelativeBox(projection, relativeParent.projection);\n                if (isDraggable(relativeParent)) {\n                    var target = projection.target;\n                    applyBoxTransforms(target, target, relativeParent.getLatestValues());\n                }\n            },\n            shouldResetTransform: function () {\n                return Boolean(props._layoutResetTransform);\n            },\n            /**\n             *\n             */\n            pointTo: function (newLead) {\n                leadProjection = newLead.projection;\n                leadLatestValues = newLead.getLatestValues();\n                /**\n                 * Subscribe to lead component's layout animations\n                 */\n                unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n                unsubscribeFromLeadVisualElement = popmotion.pipe(newLead.onSetAxisTarget(element.scheduleUpdateLayoutProjection), newLead.onLayoutAnimationComplete(function () {\n                    var _a;\n                    if (element.isPresent) {\n                        element.presence = Presence.Present;\n                    }\n                    else {\n                        (_a = element.layoutSafeToRemove) === null || _a === void 0 ? void 0 : _a.call(element);\n                    }\n                }));\n            }, \n            // TODO: Clean this up\n            isPresent: true, presence: Presence.Entering });\n        return element;\n    };\n};\nfunction fireResolveRelativeTargetBox(child) {\n    child.resolveRelativeTargetBox();\n}\nfunction fireUpdateLayoutProjection(child) {\n    child.updateLayoutProjection();\n}\nvar variantProps = tslib.__spreadArray([\"initial\"], tslib.__read(variantPriorityOrder));\nvar numVariantProps = variantProps.length;\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 === styleValueTypes.number || v === styleValueTypes.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) { 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}; };\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) {\n        var x = _a.x;\n        return x.max - x.min;\n    },\n    height: function (_a) {\n        var y = _a.y;\n        return y.max - y.min;\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, top = elementComputedStyle.top, left = elementComputedStyle.left, bottom = elementComputedStyle.bottom, right = elementComputedStyle.right, transform = elementComputedStyle.transform;\n    var originComputedStyle = { top: top, left: left, bottom: bottom, right: right, transform: transform };\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    // 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, positionalValues[key](originBbox, originComputedStyle));\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 = tslib.__assign({}, target);\n    transitionEnd = tslib.__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 to = target[key];\n        var fromType = findDimensionValueType(from);\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            for (var i = to[0] === null ? 1 : 0; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    heyListen.invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    heyListen.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 === styleValueTypes.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 = 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 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 = tslib.__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        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\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\nfunction getComputedStyle$1(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$1(domElement);\n            return ((isCSSVariable$1(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 getBoundingBox(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 = tslib.__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 tslib.__assign({ transition: transition,\n            transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n    build: function (element, renderState, latestValues, projection, layoutState, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n        buildHTMLStyles(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform\n            ? buildLayoutProjectionTransformOrigin\n            : undefined);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nvar svgVisualElement = visualElement(tslib.__assign(tslib.__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    },\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    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (_element, renderState, latestValues, projection, layoutState, options, props) {\n        var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n        buildSVGAttrs(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform\n            ? buildLayoutProjectionTransformOrigin\n            : undefined);\n    }, render: renderSVG }));\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nvar featureBundle = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, animations), gestureAnimations), drag), layoutAnimations);\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);\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));\n}\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nfunction useForceUpdate() {\n    var unloadingRef = React.useRef(false);\n    var _a = tslib.__read(React.useState(0), 2), forcedRenderCount = _a[0], setForcedRenderCount = _a[1];\n    useUnmountEffect(function () { return (unloadingRef.current = true); });\n    return React.useCallback(function () {\n        !unloadingRef.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n}\n\nvar presenceId = 0;\nfunction getPresenceId() {\n    var id = presenceId;\n    presenceId++;\n    return id;\n}\nvar PresenceChild = function (_a) {\n    var children = _a.children, initial = _a.initial, isPresent = _a.isPresent, onExitComplete = _a.onExitComplete, custom = _a.custom, presenceAffectsLayout = _a.presenceAffectsLayout;\n    var presenceChildren = useConstant(newChildrenMap);\n    var id = useConstant(getPresenceId);\n    var context = React.useMemo(function () { return ({\n        id: id,\n        initial: initial,\n        isPresent: isPresent,\n        custom: custom,\n        onExitComplete: function (childId) {\n            presenceChildren.set(childId, true);\n            var allComplete = true;\n            presenceChildren.forEach(function (isComplete) {\n                if (!isComplete)\n                    allComplete = false;\n            });\n            allComplete && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n        },\n        register: function (childId) {\n            presenceChildren.set(childId, false);\n            return function () { return presenceChildren.delete(childId); };\n        },\n    }); }, \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? undefined : [isPresent]);\n    React.useMemo(function () {\n        presenceChildren.forEach(function (_, key) { return presenceChildren.set(key, false); });\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React__namespace.useEffect(function () {\n        !isPresent && !presenceChildren.size && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n    }, [isPresent]);\n    return (React__namespace.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nfunction getChildKey(child) {\n    return child.key || \"\";\n}\nfunction updateChildLookup(children, allChildren) {\n    var seenChildren =  false ? 0 : null;\n    children.forEach(function (child) {\n        var key = getChildKey(child);\n        if (false) {}\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    var filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    React.Children.forEach(children, function (child) {\n        if (React.isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * @library\n *\n * Any `Frame` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { Frame, AnimatePresence } from 'framer'\n *\n * // As items are added and removed from `items`\n * export function Items({ items }) {\n *   return (\n *     <AnimatePresence>\n *       {items.map(item => (\n *         <Frame\n *           key={item.id}\n *           initial={{ opacity: 0 }}\n *           animate={{ opacity: 1 }}\n *           exit={{ opacity: 0 }}\n *         />\n *       ))}\n *     </AnimatePresence>\n *   )\n * }\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * @motion\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nvar AnimatePresence = function (_a) {\n    var children = _a.children, custom = _a.custom, _b = _a.initial, initial = _b === void 0 ? true : _b, onExitComplete = _a.onExitComplete, exitBeforeEnter = _a.exitBeforeEnter, _c = _a.presenceAffectsLayout, presenceAffectsLayout = _c === void 0 ? true : _c;\n    // We want to force a re-render once all exiting animations have finished. We\n    // either use a local forceRender function, or one from a parent context if it exists.\n    var forceRender = useForceUpdate();\n    var layoutContext = React.useContext(SharedLayoutContext);\n    if (isSharedLayout(layoutContext)) {\n        forceRender = layoutContext.forceUpdate;\n    }\n    var isInitialRender = React.useRef(true);\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    var filteredChildren = onlyElements(children);\n    // Keep a living record of the children we're actually rendering so we\n    // can diff to figure out which are entering and exiting\n    var presentChildren = React.useRef(filteredChildren);\n    // A lookup table to quickly reference components by key\n    var allChildren = React.useRef(new Map())\n        .current;\n    // A living record of all currently exiting components.\n    var exiting = React.useRef(new Set()).current;\n    updateChildLookup(filteredChildren, allChildren);\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    if (isInitialRender.current) {\n        isInitialRender.current = false;\n        return (React__namespace.createElement(React__namespace.Fragment, null, filteredChildren.map(function (child) { return (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)); })));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    var childrenToRender = tslib.__spreadArray([], tslib.__read(filteredChildren));\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    var presentKeys = presentChildren.current.map(getChildKey);\n    var targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    var numPresent = presentKeys.length;\n    for (var i = 0; i < numPresent; i++) {\n        var key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1) {\n            exiting.add(key);\n        }\n        else {\n            // In case this key has re-entered, remove from the exiting list\n            exiting.delete(key);\n        }\n    }\n    // If we currently have exiting children, and we're deferring rendering incoming children\n    // until after all current children have exiting, empty the childrenToRender array\n    if (exitBeforeEnter && exiting.size) {\n        childrenToRender = [];\n    }\n    // Loop through all currently exiting components and clone them to overwrite `animate`\n    // with any `exit` prop they might have defined.\n    exiting.forEach(function (key) {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        var child = allChildren.get(key);\n        if (!child)\n            return;\n        var insertionIndex = presentKeys.indexOf(key);\n        var onExit = function () {\n            allChildren.delete(key);\n            exiting.delete(key);\n            // Remove this child from the present children\n            var removeIndex = presentChildren.current.findIndex(function (presentChild) { return presentChild.key === key; });\n            presentChildren.current.splice(removeIndex, 1);\n            // Defer re-rendering until all exiting children have indeed left\n            if (!exiting.size) {\n                presentChildren.current = filteredChildren;\n                forceRender();\n                onExitComplete && onExitComplete();\n            }\n        };\n        childrenToRender.splice(insertionIndex, 0, React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    // Add `MotionContext` even to children that don't need it to ensure we're rendering\n    // the same tree between renders\n    childrenToRender = childrenToRender.map(function (child) {\n        var key = child.key;\n        return exiting.has(key) ? (child) : (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    presentChildren.current = childrenToRender;\n    if (false) {}\n    return (React__namespace.createElement(React__namespace.Fragment, null, exiting.size\n        ? childrenToRender\n        : childrenToRender.map(function (child) { return React.cloneElement(child); })));\n};\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    };\n}\n\nfunction createCrossfader() {\n    /**\n     * The current state of the crossfade as a value between 0 and 1\n     */\n    var progress = motionValue(1);\n    var options = {\n        lead: undefined,\n        follow: undefined,\n        crossfadeOpacity: false,\n        preserveFollowOpacity: false,\n    };\n    var prevOptions = tslib.__assign({}, options);\n    var leadState = {};\n    var followState = {};\n    /**\n     *\n     */\n    var isActive = false;\n    /**\n     *\n     */\n    var finalCrossfadeFrame = null;\n    /**\n     * Framestamp of the last frame we updated values at.\n     */\n    var prevUpdate = 0;\n    function startCrossfadeAnimation(target, transition) {\n        var lead = options.lead, follow = options.follow;\n        isActive = true;\n        finalCrossfadeFrame = null;\n        var hasUpdated = false;\n        var onUpdate = function () {\n            hasUpdated = true;\n            lead && lead.scheduleRender();\n            follow && follow.scheduleRender();\n        };\n        var onComplete = function () {\n            isActive = false;\n            /**\n             * If the crossfade animation is no longer active, flag a frame\n             * that we're still allowed to crossfade\n             */\n            finalCrossfadeFrame = sync.getFrameData().timestamp;\n        };\n        transition = transition && getValueTransition(transition, \"crossfade\");\n        return animate(progress, target, tslib.__assign(tslib.__assign({}, transition), { onUpdate: onUpdate, onComplete: function () {\n                if (!hasUpdated) {\n                    progress.set(target);\n                    /**\n                     * If we never ran an update, for instance if this was an instant transition, fire a\n                     * simulated final frame to ensure the crossfade gets applied correctly.\n                     */\n                    sync__default['default'].read(onComplete);\n                }\n                else {\n                    onComplete();\n                }\n                onUpdate();\n            } }));\n    }\n    function updateCrossfade() {\n        var _a, _b;\n        /**\n         * We only want to compute the crossfade once per frame, so we\n         * compare the previous update framestamp with the current frame\n         * and early return if they're the same.\n         */\n        var timestamp = sync.getFrameData().timestamp;\n        var lead = options.lead, follow = options.follow;\n        if (timestamp === prevUpdate || !lead)\n            return;\n        prevUpdate = timestamp;\n        /**\n         * Merge each component's latest values into our crossfaded state\n         * before crossfading.\n         */\n        var latestLeadValues = lead.getLatestValues();\n        Object.assign(leadState, latestLeadValues);\n        var latestFollowValues = follow\n            ? follow.getLatestValues()\n            : options.prevValues;\n        Object.assign(followState, latestFollowValues);\n        var p = progress.get();\n        /**\n         * Crossfade the opacity between the two components. This will result\n         * in a different opacity for each component.\n         */\n        var leadTargetOpacity = (_a = latestLeadValues.opacity) !== null && _a !== void 0 ? _a : 1;\n        var followTargetOpacity = (_b = latestFollowValues === null || latestFollowValues === void 0 ? void 0 : latestFollowValues.opacity) !== null && _b !== void 0 ? _b : 1;\n        if (options.crossfadeOpacity && follow) {\n            leadState.opacity = popmotion.mix(\n            /**\n             * If the follow child has been completely hidden we animate\n             * this opacity from its previous opacity, but otherwise from completely transparent.\n             */\n            follow.isVisible !== false ? 0 : followTargetOpacity, leadTargetOpacity, easeCrossfadeIn(p));\n            followState.opacity = options.preserveFollowOpacity\n                ? followTargetOpacity\n                : popmotion.mix(followTargetOpacity, 0, easeCrossfadeOut(p));\n        }\n        else if (!follow) {\n            leadState.opacity = popmotion.mix(followTargetOpacity, leadTargetOpacity, p);\n        }\n        mixValues(leadState, followState, latestLeadValues, latestFollowValues || {}, Boolean(follow), p);\n    }\n    return {\n        isActive: function () {\n            return leadState &&\n                (isActive || sync.getFrameData().timestamp === finalCrossfadeFrame);\n        },\n        fromLead: function (transition) {\n            return startCrossfadeAnimation(0, transition);\n        },\n        toLead: function (transition) {\n            var initialProgress = 0;\n            if (!options.prevValues && !options.follow) {\n                /**\n                 * If we're not coming from anywhere, start at the end of the animation.\n                 */\n                initialProgress = 1;\n            }\n            else if (prevOptions.lead === options.follow &&\n                prevOptions.follow === options.lead) {\n                /**\n                 * If we're swapping follow/lead we can reverse the progress\n                 */\n                initialProgress = 1 - progress.get();\n            }\n            progress.set(initialProgress);\n            return startCrossfadeAnimation(1, transition);\n        },\n        reset: function () { return progress.set(1); },\n        stop: function () { return progress.stop(); },\n        getCrossfadeState: function (element) {\n            updateCrossfade();\n            if (element === options.lead) {\n                return leadState;\n            }\n            else if (element === options.follow) {\n                return followState;\n            }\n        },\n        setOptions: function (newOptions) {\n            prevOptions = options;\n            options = newOptions;\n            leadState = {};\n            followState = {};\n        },\n        getLatestValues: function () {\n            return leadState;\n        },\n    };\n}\nvar easeCrossfadeIn = compress(0, 0.5, popmotion.circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, popmotion.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(popmotion.progress(min, max, p));\n    };\n}\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nfunction mixValues(leadState, followState, latestLeadValues, latestFollowValues, hasFollowElement, p) {\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\" + borders[i] + \"Radius\";\n        var followRadius = getRadius(latestFollowValues, borderLabel);\n        var leadRadius = getRadius(latestLeadValues, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        /**\n         * Currently we're only crossfading between numerical border radius.\n         * It would be possible to crossfade between percentages for a little\n         * extra bundle size.\n         */\n        if (typeof followRadius === \"number\" &&\n            typeof leadRadius === \"number\") {\n            var radius = Math.max(popmotion.mix(followRadius, leadRadius, p), 0);\n            leadState[borderLabel] = followState[borderLabel] = radius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (latestFollowValues.rotate || latestLeadValues.rotate) {\n        var rotate = popmotion.mix(latestFollowValues.rotate || 0, latestLeadValues.rotate || 0, p);\n        leadState.rotate = followState.rotate = rotate;\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 (!hasFollowElement &&\n        latestLeadValues.backgroundColor &&\n        latestFollowValues.backgroundColor) {\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 = popmotion.mixColor(latestFollowValues.backgroundColor, latestLeadValues.backgroundColor)(p);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n\nfunction layoutStack() {\n    var stack = new Set();\n    var state = { leadIsExiting: false };\n    var prevState = tslib.__assign({}, state);\n    var prevValues;\n    var prevViewportBox;\n    var prevDragCursor;\n    var crossfader = createCrossfader();\n    var needsCrossfadeAnimation = false;\n    function getFollowViewportBox() {\n        return state.follow ? state.follow.prevViewportBox : prevViewportBox;\n    }\n    function getFollowLayout() {\n        var _a;\n        return (_a = state.follow) === null || _a === void 0 ? void 0 : _a.getLayoutState().layout;\n    }\n    return {\n        add: function (element) {\n            element.setCrossfader(crossfader);\n            stack.add(element);\n            /**\n             * Hydrate new element with previous drag position if we have one\n             */\n            if (prevDragCursor)\n                element.prevDragCursor = prevDragCursor;\n            if (!state.lead)\n                state.lead = element;\n        },\n        remove: function (element) {\n            stack.delete(element);\n        },\n        getLead: function () { return state.lead; },\n        updateSnapshot: function () {\n            if (!state.lead)\n                return;\n            prevValues = crossfader.isActive()\n                ? crossfader.getLatestValues()\n                : state.lead.getLatestValues();\n            prevViewportBox = state.lead.prevViewportBox;\n            var dragControls = elementDragControls.get(state.lead);\n            if (dragControls && dragControls.isDragging) {\n                prevDragCursor = dragControls.cursorProgress;\n            }\n        },\n        clearSnapshot: function () {\n            prevDragCursor = prevViewportBox = undefined;\n        },\n        updateLeadAndFollow: function () {\n            var _a;\n            prevState = tslib.__assign({}, state);\n            var lead;\n            var follow;\n            var order = Array.from(stack);\n            for (var i = order.length; i--; i >= 0) {\n                var element = order[i];\n                if (lead)\n                    follow !== null && follow !== void 0 ? follow : (follow = element);\n                lead !== null && lead !== void 0 ? lead : (lead = element);\n                if (lead && follow)\n                    break;\n            }\n            state.lead = lead;\n            state.follow = follow;\n            state.leadIsExiting = ((_a = state.lead) === null || _a === void 0 ? void 0 : _a.presence) === Presence.Exiting;\n            crossfader.setOptions({\n                lead: lead,\n                follow: follow,\n                prevValues: prevValues,\n                crossfadeOpacity: (follow === null || follow === void 0 ? void 0 : follow.isPresenceRoot) || (lead === null || lead === void 0 ? void 0 : lead.isPresenceRoot),\n            });\n            if (\n            // Don't crossfade if we've just animated back from lead and switched the\n            // old follow to the new lead.\n            state.lead !== prevState.follow &&\n                (prevState.lead !== state.lead ||\n                    prevState.leadIsExiting !== state.leadIsExiting)) {\n                needsCrossfadeAnimation = true;\n            }\n        },\n        animate: function (child, shouldCrossfade) {\n            var _a;\n            if (shouldCrossfade === void 0) { shouldCrossfade = false; }\n            if (child === state.lead) {\n                if (shouldCrossfade) {\n                    /**\n                     * Point a lead to itself in case it was previously pointing\n                     * to a different visual element\n                     */\n                    child.pointTo(state.lead);\n                }\n                else {\n                    child.setVisibility(true);\n                }\n                var config = {};\n                var prevParent = (_a = state.follow) === null || _a === void 0 ? void 0 : _a.getProjectionParent();\n                if (prevParent) {\n                    /**\n                     * We'll use this to determine if the element or its layoutId has been reparented.\n                     */\n                    config.prevParent = prevParent;\n                }\n                if (child.presence === Presence.Entering) {\n                    config.originBox = getFollowViewportBox();\n                }\n                else if (child.presence === Presence.Exiting) {\n                    config.targetBox = getFollowLayout();\n                }\n                if (needsCrossfadeAnimation) {\n                    needsCrossfadeAnimation = false;\n                    var transition = child.getDefaultTransition();\n                    child.presence === Presence.Entering\n                        ? crossfader.toLead(transition)\n                        : crossfader.fromLead(transition);\n                }\n                child.notifyLayoutReady(config);\n            }\n            else {\n                if (shouldCrossfade) {\n                    state.lead && child.pointTo(state.lead);\n                }\n                else {\n                    child.setVisibility(false);\n                }\n            }\n        },\n    };\n}\n\nfunction resetRotate(child) {\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 (!child.hasValue(key) || child.getStaticValue(key) === 0)\n            continue;\n        hasRotate = true;\n        // Record the rotation and then temporarily set it to 0\n        resetValues[key] = child.getStaticValue(key);\n        child.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    child.syncRender();\n    // Put back all the values we reset\n    for (var key in resetValues) {\n        child.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    child.scheduleRender();\n}\n\n/**\n * @public\n */\nvar AnimateSharedLayout = /** @class */ (function (_super) {\n    tslib.__extends(AnimateSharedLayout, _super);\n    function AnimateSharedLayout() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /**\n         * A list of all the children in the shared layout\n         */\n        _this.children = new Set();\n        /**\n         * As animate components with a defined `layoutId` are added/removed to the tree,\n         * we store them in order. When one is added, it will animate out from the\n         * previous one, and when it's removed, it'll animate to the previous one.\n         */\n        _this.stacks = new Map();\n        /**\n         * Track whether the component has mounted. If it hasn't, the presence of added children\n         * are set to Present, whereas if it has they're considered Entering\n         */\n        _this.hasMounted = false;\n        /**\n         * Track whether we already have an update scheduled. If we don't, we'll run snapshots\n         * and schedule one.\n         */\n        _this.updateScheduled = false;\n        /**\n         * Tracks whether we already have a render scheduled. If we don't, we'll force one with this.forceRender\n         */\n        _this.renderScheduled = false;\n        /**\n         * The methods provided to all children in the shared layout tree.\n         */\n        _this.syncContext = tslib.__assign(tslib.__assign({}, createBatcher()), { syncUpdate: function (force) { return _this.scheduleUpdate(force); }, forceUpdate: function () {\n                // By copying syncContext to itself, when this component re-renders it'll also re-render\n                // all children subscribed to the SharedLayout context.\n                _this.syncContext = tslib.__assign({}, _this.syncContext);\n                _this.scheduleUpdate(true);\n            }, register: function (child) { return _this.addChild(child); }, remove: function (child) { return _this.removeChild(child); } });\n        return _this;\n    }\n    AnimateSharedLayout.prototype.componentDidMount = function () {\n        this.hasMounted = true;\n    };\n    AnimateSharedLayout.prototype.componentDidUpdate = function () {\n        this.startLayoutAnimation();\n    };\n    AnimateSharedLayout.prototype.shouldComponentUpdate = function () {\n        this.renderScheduled = true;\n        return true;\n    };\n    AnimateSharedLayout.prototype.startLayoutAnimation = function () {\n        var _this = this;\n        /**\n         * Reset update and render scheduled status\n         */\n        this.renderScheduled = this.updateScheduled = false;\n        var type = this.props.type;\n        /**\n         * Update presence metadata based on the latest AnimatePresence status.\n         * This is a kind of goofy way of dealing with this, perhaps there's a better model to find.\n         */\n        this.children.forEach(function (child) {\n            if (!child.isPresent) {\n                child.presence = Presence.Exiting;\n            }\n            else if (child.presence !== Presence.Entering) {\n                child.presence =\n                    child.presence === Presence.Exiting\n                        ? Presence.Entering\n                        : Presence.Present;\n            }\n        });\n        this.updateStacks();\n        /**\n         * Create a handler which we can use to flush the children animations\n         */\n        var handler = {\n            layoutReady: function (child) {\n                if (child.getLayoutId() !== undefined) {\n                    var stack = _this.getStack(child);\n                    stack.animate(child, type === \"crossfade\");\n                }\n                else {\n                    child.notifyLayoutReady();\n                }\n            },\n            parent: this.context.visualElement,\n        };\n        /**\n         * Shared layout animations can be used without the AnimateSharedLayout wrapping component.\n         * This requires some co-ordination across components to stop layout thrashing\n         * and ensure measurements are taken at the correct time.\n         *\n         * Here we use that same mechanism of schedule/flush.\n         */\n        this.children.forEach(function (child) { return _this.syncContext.add(child); });\n        this.syncContext.flush(handler);\n        /**\n         * Clear snapshots so subsequent rerenders don't retain memory of outgoing components\n         */\n        this.stacks.forEach(function (stack) { return stack.clearSnapshot(); });\n    };\n    AnimateSharedLayout.prototype.updateStacks = function () {\n        this.stacks.forEach(function (stack) { return stack.updateLeadAndFollow(); });\n    };\n    AnimateSharedLayout.prototype.scheduleUpdate = function (force) {\n        if (force === void 0) { force = false; }\n        if (!(force || !this.updateScheduled))\n            return;\n        /**\n         * Flag we've scheduled an update\n         */\n        this.updateScheduled = true;\n        /**\n         * Write: Reset transforms so bounding boxes can be accurately measured.\n         */\n        this.children.forEach(function (child) {\n            resetRotate(child);\n            if (child.shouldResetTransform())\n                child.resetTransform();\n        });\n        /**\n         * Read: Snapshot children\n         */\n        this.children.forEach(snapshotViewportBox);\n        /**\n         * Every child keeps a local snapshot, but we also want to record\n         * snapshots of the visible children as, if they're are being removed\n         * in this render, we can still access them.\n         *\n         * TODO: What would be better here is doing a single loop where we\n         * only snapshotViewportBoxes of undefined layoutIds and then one for each stack\n         */\n        this.stacks.forEach(function (stack) { return stack.updateSnapshot(); });\n        /**\n         * Force a rerender by setting state if we aren't already going to render.\n         */\n        if (force || !this.renderScheduled) {\n            this.renderScheduled = true;\n            this.forceUpdate();\n        }\n    };\n    AnimateSharedLayout.prototype.addChild = function (child) {\n        this.children.add(child);\n        this.addToStack(child);\n        child.presence = this.hasMounted ? Presence.Entering : Presence.Present;\n    };\n    AnimateSharedLayout.prototype.removeChild = function (child) {\n        this.scheduleUpdate();\n        this.children.delete(child);\n        this.removeFromStack(child);\n    };\n    AnimateSharedLayout.prototype.addToStack = function (child) {\n        var stack = this.getStack(child);\n        stack === null || stack === void 0 ? void 0 : stack.add(child);\n    };\n    AnimateSharedLayout.prototype.removeFromStack = function (child) {\n        var stack = this.getStack(child);\n        stack === null || stack === void 0 ? void 0 : stack.remove(child);\n    };\n    /**\n     * Return a stack of animate children based on the provided layoutId.\n     * Will create a stack if none currently exists with that layoutId.\n     */\n    AnimateSharedLayout.prototype.getStack = function (child) {\n        var id = child.getLayoutId();\n        if (id === undefined)\n            return;\n        // Create stack if it doesn't already exist\n        !this.stacks.has(id) && this.stacks.set(id, layoutStack());\n        return this.stacks.get(id);\n    };\n    AnimateSharedLayout.prototype.render = function () {\n        return (React__namespace.createElement(SharedLayoutContext.Provider, { value: this.syncContext }, this.props.children));\n    };\n    AnimateSharedLayout.contextType = MotionContext;\n    return AnimateSharedLayout;\n}(React__namespace.Component));\n\n/**\n * `MotionConfig` is used to set configuration options for all children `motion` components.\n *\n * ```jsx\n * import { motion, MotionConfig } from \"framer-motion\"\n *\n * export function App() {\n *   return (\n *     <MotionConfig transition={{ type: \"spring\" }}>\n *       <motion.div animate={{ x: 100 }} />\n *     </MotionConfig>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction MotionConfig(_a) {\n    var children = _a.children, config = tslib.__rest(_a, [\"children\"]);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = tslib.__assign(tslib.__assign({}, React.useContext(MotionConfigContext)), config);\n    /**\n     * Don't allow isStatic to change between renders as it affects how many hooks\n     * motion components fire.\n     */\n    config.isStatic = useConstant(function () { return config.isStatic; });\n    /**\n     * Creating a new config context object will re-render every `motion` component\n     * every time it renders. So we only want to create a new one sparingly.\n     */\n    var transitionDependency = typeof config.transition === \"object\"\n        ? config.transition.toString()\n        : \"\";\n    var context = React.useMemo(function () { return config; }, [\n        transitionDependency,\n        config.transformPagePoint,\n    ]);\n    return (React__namespace.createElement(MotionConfigContext.Provider, { value: context }, children));\n}\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = tslib.__read(React.useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = React.useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = tslib.__rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    React.useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = tslib.__rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React__namespace.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\n/**\n * @public\n */\nvar domAnimation = tslib.__assign(tslib.__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\n/**\n * @public\n */\nvar domMax = tslib.__assign(tslib.__assign(tslib.__assign({}, domAnimation), drag), layoutAnimations);\n\n/**\n * Creates a `MotionValue` to track the state and velocity of a value.\n *\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\n *\n * @library\n *\n * ```jsx\n * export function MyComponent() {\n *   const scale = useMotionValue(1)\n *\n *   return <Frame scale={scale} />\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const scale = useMotionValue(1)\n *\n *   return <motion.div style={{ scale }} />\n * }\n * ```\n *\n * @param initial - The initial state.\n *\n * @public\n */\nfunction useMotionValue(initial) {\n    var value = useConstant(function () { return motionValue(initial); });\n    /**\n     * If this motion value is being used in static mode, like on\n     * the Framer canvas, force components to rerender when the motion\n     * value is updated.\n     */\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    if (isStatic) {\n        var _a = tslib.__read(React.useState(initial), 2), setLatest_1 = _a[1];\n        React.useEffect(function () { return value.onChange(setLatest_1); }, []);\n    }\n    return value;\n}\n\nfunction useOnChange(value, callback) {\n    React.useEffect(function () {\n        if (isMotionValue(value))\n            return value.onChange(callback);\n    }, [callback]);\n}\nfunction useMultiOnChange(values, handler) {\n    React.useEffect(function () {\n        var subscriptions = values.map(function (value) { return value.onChange(handler); });\n        return function () { return subscriptions.forEach(function (unsubscribe) { return unsubscribe(); }); };\n    });\n}\n\nfunction useCombineMotionValues(values, combineValues) {\n    /**\n     * Initialise the returned motion value. This remains the same between renders.\n     */\n    var value = useMotionValue(combineValues());\n    /**\n     * Create a function that will update the template motion value with the latest values.\n     * This is pre-bound so whenever a motion value updates it can schedule its\n     * execution in Framesync. If it's already been scheduled it won't be fired twice\n     * in a single frame.\n     */\n    var updateValue = function () { return value.set(combineValues()); };\n    /**\n     * Synchronously update the motion value with the latest values during the render.\n     * This ensures that within a React render, the styles applied to the DOM are up-to-date.\n     */\n    updateValue();\n    /**\n     * Subscribe to all motion values found within the template. Whenever any of them change,\n     * schedule an update.\n     */\n    useMultiOnChange(values, function () { return sync__default['default'].update(updateValue, false, true); });\n    return value;\n}\n\n/**\n * Combine multiple motion values into a new one using a string template literal.\n *\n * ```jsx\n * import {\n *   motion,\n *   useSpring,\n *   useMotionValue,\n *   useMotionTemplate\n * } from \"framer-motion\"\n *\n * function Component() {\n *   const shadowX = useSpring(0)\n *   const shadowY = useMotionValue(0)\n *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`\n *\n *   return <motion.div style={{ filter: shadow }} />\n * }\n * ```\n *\n * @public\n */\nfunction useMotionTemplate(fragments) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    /**\n     * Create a function that will build a string from the latest motion values.\n     */\n    var numFragments = fragments.length;\n    function buildValue() {\n        var output = \"\";\n        for (var i = 0; i < numFragments; i++) {\n            output += fragments[i];\n            var value = values[i];\n            if (value)\n                output += values[i].get();\n        }\n        return output;\n    }\n    return useCombineMotionValues(values, buildValue);\n}\n\nvar isCustomValueType = function (v) {\n    return typeof v === \"object\" && v.mix;\n};\nvar getMixer = function (v) { return (isCustomValueType(v) ? v.mix : undefined); };\nfunction transform() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var useImmediate = !Array.isArray(args[0]);\n    var argOffset = useImmediate ? 0 : -1;\n    var inputValue = args[0 + argOffset];\n    var inputRange = args[1 + argOffset];\n    var outputRange = args[2 + argOffset];\n    var options = args[3 + argOffset];\n    var interpolator = popmotion.interpolate(inputRange, outputRange, tslib.__assign({ mixer: getMixer(outputRange[0]) }, options));\n    return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\nfunction useTransform(input, inputRangeOrTransformer, outputRange, options) {\n    var transformer = typeof inputRangeOrTransformer === \"function\"\n        ? inputRangeOrTransformer\n        : transform(inputRangeOrTransformer, outputRange, options);\n    return Array.isArray(input)\n        ? useListTransform(input, transformer)\n        : useListTransform([input], function (_a) {\n            var _b = tslib.__read(_a, 1), latest = _b[0];\n            return transformer(latest);\n        });\n}\nfunction useListTransform(values, transformer) {\n    var latest = useConstant(function () { return []; });\n    return useCombineMotionValues(values, function () {\n        latest.length = 0;\n        var numValues = values.length;\n        for (var i = 0; i < numValues; i++) {\n            latest[i] = values[i].get();\n        }\n        return transformer(latest);\n    });\n}\n\n/**\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\n *\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\n * to another `MotionValue`.\n *\n * @remarks\n *\n * ```jsx\n * const x = useSpring(0, { stiffness: 300 })\n * const y = useSpring(x, { damping: 10 })\n * ```\n *\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\n * @param springConfig - Configuration options for the spring.\n * @returns `MotionValue`\n *\n * @public\n */\nfunction useSpring(source, config) {\n    if (config === void 0) { config = {}; }\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    var activeSpringAnimation = React.useRef(null);\n    var value = useMotionValue(isMotionValue(source) ? source.get() : source);\n    React.useMemo(function () {\n        return value.attach(function (v, set) {\n            /**\n             * A more hollistic approach to this might be to use isStatic to fix VisualElement animations\n             * at that level, but this will work for now\n             */\n            if (isStatic)\n                return set(v);\n            if (activeSpringAnimation.current) {\n                activeSpringAnimation.current.stop();\n            }\n            activeSpringAnimation.current = popmotion.animate(tslib.__assign(tslib.__assign({ from: value.get(), to: v, velocity: value.getVelocity() }, config), { onUpdate: set }));\n            return value.get();\n        });\n    }, Object.values(config));\n    useOnChange(source, function (v) { return value.set(parseFloat(v)); });\n    return value;\n}\n\n/**\n * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.\n *\n * ```javascript\n * const x = useMotionValue(0)\n * const xVelocity = useVelocity(x)\n * const xAcceleration = useVelocity(xVelocity)\n * ```\n *\n * @public\n */\nfunction useVelocity(value) {\n    var velocity = useMotionValue(value.getVelocity());\n    React.useEffect(function () {\n        return value.velocityUpdateSubscribers.add(function (newVelocity) {\n            velocity.set(newVelocity);\n        });\n    }, [value]);\n    return velocity;\n}\n\nfunction createScrollMotionValues() {\n    return {\n        scrollX: motionValue(0),\n        scrollY: motionValue(0),\n        scrollXProgress: motionValue(0),\n        scrollYProgress: motionValue(0),\n    };\n}\nfunction setProgress(offset, maxOffset, value) {\n    value.set(!offset || !maxOffset ? 0 : offset / maxOffset);\n}\nfunction createScrollUpdater(values, getOffsets) {\n    var update = function () {\n        var _a = getOffsets(), xOffset = _a.xOffset, yOffset = _a.yOffset, xMaxOffset = _a.xMaxOffset, yMaxOffset = _a.yMaxOffset;\n        // Set absolute positions\n        values.scrollX.set(xOffset);\n        values.scrollY.set(yOffset);\n        // Set 0-1 progress\n        setProgress(xOffset, xMaxOffset, values.scrollXProgress);\n        setProgress(yOffset, yMaxOffset, values.scrollYProgress);\n    };\n    update();\n    return update;\n}\n\nvar getElementScrollOffsets = function (element) { return function () {\n    return {\n        xOffset: element.scrollLeft,\n        yOffset: element.scrollTop,\n        xMaxOffset: element.scrollWidth - element.offsetWidth,\n        yMaxOffset: element.scrollHeight - element.offsetHeight,\n    };\n}; };\n/**\n * Returns MotionValues that update when the provided element scrolls:\n *\n * - `scrollX` — Horizontal scroll distance in pixels.\n * - `scrollY` — Vertical scroll distance in pixels.\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\n *\n * This element must be set to `overflow: scroll` on either or both axes to report scroll offset.\n *\n * @library\n *\n * ```jsx\n * import * as React from \"react\"\n * import {\n *   Frame,\n *   useElementScroll,\n *   useTransform\n * } from \"framer\"\n *\n * export function MyComponent() {\n *   const ref = React.useRef()\n *   const { scrollYProgress } = useElementScroll(ref)\n *\n *   return (\n *     <Frame ref={ref}>\n *       <Frame scaleX={scrollYProgress} />\n *     </Frame>\n *   )\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const ref = useRef()\n *   const { scrollYProgress } = useElementScroll(ref)\n *\n *   return (\n *     <div ref={ref}>\n *       <motion.div style={{ scaleX: scrollYProgress }} />\n *     </div>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction useElementScroll(ref) {\n    var values = useConstant(createScrollMotionValues);\n    useIsomorphicLayoutEffect(function () {\n        var element = ref.current;\n        heyListen.invariant(!!element, \"ref provided to useScroll must be passed into a HTML element.\");\n        if (!element)\n            return;\n        var updateScrollValues = createScrollUpdater(values, getElementScrollOffsets(element));\n        var scrollListener = addDomEvent(element, \"scroll\", updateScrollValues, { passive: true });\n        var resizeListener = addDomEvent(element, \"resize\", updateScrollValues);\n        return function () {\n            scrollListener && scrollListener();\n            resizeListener && resizeListener();\n        };\n    }, []);\n    return values;\n}\n\nvar viewportScrollValues;\nfunction getViewportScrollOffsets() {\n    return {\n        xOffset: window.pageXOffset,\n        yOffset: window.pageYOffset,\n        xMaxOffset: document.body.clientWidth - window.innerWidth,\n        yMaxOffset: document.body.clientHeight - window.innerHeight,\n    };\n}\nvar hasListeners = false;\nfunction addEventListeners() {\n    hasListeners = true;\n    if (typeof window === \"undefined\")\n        return;\n    var updateScrollValues = createScrollUpdater(viewportScrollValues, getViewportScrollOffsets);\n    addDomEvent(window, \"scroll\", updateScrollValues, { passive: true });\n    addDomEvent(window, \"resize\", updateScrollValues);\n}\n/**\n * Returns MotionValues that update when the viewport scrolls:\n *\n * - `scrollX` — Horizontal scroll distance in pixels.\n * - `scrollY` — Vertical scroll distance in pixels.\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\n *\n * **Warning:** Setting `body` or `html` to `height: 100%` or similar will break the `Progress`\n * values as this breaks the browser's capability to accurately measure the page length.\n *\n * @library\n *\n * ```jsx\n * import * as React from \"react\"\n * import {\n *   Frame,\n *   useViewportScroll,\n *   useTransform\n * } from \"framer\"\n *\n * export function MyComponent() {\n *   const { scrollYProgress } = useViewportScroll()\n *   return <Frame scaleX={scrollYProgress} />\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const { scrollYProgress } = useViewportScroll()\n *   return <motion.div style={{ scaleX: scrollYProgress }} />\n * }\n * ```\n *\n * @public\n */\nfunction useViewportScroll() {\n    /**\n     * Lazy-initialise the viewport scroll values\n     */\n    if (!viewportScrollValues) {\n        viewportScrollValues = createScrollMotionValues();\n    }\n    useIsomorphicLayoutEffect(function () {\n        !hasListeners && addEventListeners();\n    }, []);\n    return viewportScrollValues;\n}\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion;\nfunction initPrefersReducedMotion() {\n    prefersReducedMotion = motionValue(null);\n    if (typeof window === \"undefined\")\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return prefersReducedMotion.set(motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.set(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    !prefersReducedMotion && initPrefersReducedMotion();\n    var _a = tslib.__read(React.useState(prefersReducedMotion.get()), 2), shouldReduceMotion = _a[0], setShouldReduceMotion = _a[1];\n    useOnChange(prefersReducedMotion, setShouldReduceMotion);\n    return shouldReduceMotion;\n}\n\n/**\n * @public\n */\nfunction animationControls() {\n    /**\n     * Track whether the host component has mounted.\n     */\n    var hasMounted = false;\n    /**\n     * Pending animations that are started before a component is mounted.\n     * TODO: Remove this as animations should only run in effects\n     */\n    var pendingAnimations = [];\n    /**\n     * A collection of linked component animation controls.\n     */\n    var subscribers = new Set();\n    var controls = {\n        subscribe: function (visualElement) {\n            subscribers.add(visualElement);\n            return function () { return void subscribers.delete(visualElement); };\n        },\n        start: function (definition, transitionOverride) {\n            /**\n             * TODO: We only perform this hasMounted check because in Framer we used to\n             * encourage the ability to start an animation within the render phase. This\n             * isn't behaviour concurrent-safe so when we make Framer concurrent-safe\n             * we can ditch this.\n             */\n            if (hasMounted) {\n                var animations_1 = [];\n                subscribers.forEach(function (visualElement) {\n                    animations_1.push(animateVisualElement(visualElement, definition, {\n                        transitionOverride: transitionOverride,\n                    }));\n                });\n                return Promise.all(animations_1);\n            }\n            else {\n                return new Promise(function (resolve) {\n                    pendingAnimations.push({\n                        animation: [definition, transitionOverride],\n                        resolve: resolve,\n                    });\n                });\n            }\n        },\n        set: function (definition) {\n            heyListen.invariant(hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            return subscribers.forEach(function (visualElement) {\n                setValues(visualElement, definition);\n            });\n        },\n        stop: function () {\n            subscribers.forEach(function (visualElement) {\n                stopAnimation(visualElement);\n            });\n        },\n        mount: function () {\n            hasMounted = true;\n            pendingAnimations.forEach(function (_a) {\n                var animation = _a.animation, resolve = _a.resolve;\n                controls.start.apply(controls, tslib.__spreadArray([], tslib.__read(animation))).then(resolve);\n            });\n            return function () {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\n/**\n * Creates `AnimationControls`, which can be used to manually start, stop\n * and sequence animations on one or more components.\n *\n * The returned `AnimationControls` should be passed to the `animate` property\n * of the components you want to animate.\n *\n * These components can then be animated with the `start` method.\n *\n * @library\n *\n * ```jsx\n * import * as React from 'react'\n * import { Frame, useAnimation } from 'framer'\n *\n * export function MyComponent(props) {\n *    const controls = useAnimation()\n *\n *    controls.start({\n *        x: 100,\n *        transition: { duration: 0.5 },\n *    })\n *\n *    return <Frame animate={controls} />\n * }\n * ```\n *\n * @motion\n *\n * ```jsx\n * import * as React from 'react'\n * import { motion, useAnimation } from 'framer-motion'\n *\n * export function MyComponent(props) {\n *    const controls = useAnimation()\n *\n *    controls.start({\n *        x: 100,\n *        transition: { duration: 0.5 },\n *    })\n *\n *    return <motion.div animate={controls} />\n * }\n * ```\n *\n * @returns Animation controller with `start` and `stop` methods\n *\n * @public\n */\nfunction useAnimation() {\n    var controls = useConstant(animationControls);\n    React.useEffect(controls.mount, []);\n    return controls;\n}\n\n/**\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\n *\n * @library\n *\n * ```jsx\n * import * as React from \"react\"\n * import { Frame, useCycle } from \"framer\"\n *\n * export function MyComponent() {\n *   const [x, cycleX] = useCycle(0, 50, 100)\n *\n *   return (\n *     <Frame\n *       animate={{ x: x }}\n *       onTap={() => cycleX()}\n *      />\n *    )\n * }\n * ```\n *\n * @motion\n *\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\n *\n * ```jsx\n * import * as React from \"react\"\n * import { motion, useCycle } from \"framer-motion\"\n *\n * export const MyComponent = () => {\n *   const [x, cycleX] = useCycle(0, 50, 100)\n *\n *   return (\n *     <motion.div\n *       animate={{ x: x }}\n *       onTap={() => cycleX()}\n *      />\n *    )\n * }\n * ```\n *\n * @param items - items to cycle through\n * @returns [currentState, cycleState]\n *\n * @public\n */\nfunction useCycle() {\n    var items = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        items[_i] = arguments[_i];\n    }\n    var index = React.useRef(0);\n    var _a = tslib.__read(React.useState(items[index.current]), 2), item = _a[0], setItem = _a[1];\n    return [\n        item,\n        function (next) {\n            index.current =\n                typeof next !== \"number\"\n                    ? popmotion.wrap(0, items.length, index.current + 1)\n                    : next;\n            setItem(items[index.current]);\n        },\n    ];\n}\n\n/**\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\n *\n * @library\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <Frame onTapStart={startDrag} />\n *     <Frame drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @motion\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nvar DragControls = /** @class */ (function () {\n    function DragControls() {\n        this.componentControls = new Set();\n    }\n    /**\n     * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.\n     *\n     * @internal\n     */\n    DragControls.prototype.subscribe = function (controls) {\n        var _this = this;\n        this.componentControls.add(controls);\n        return function () { return _this.componentControls.delete(controls); };\n    };\n    /**\n     * Start a drag gesture on every `motion` component that has this set of drag controls\n     * passed into it via the `dragControls` prop.\n     *\n     * ```jsx\n     * dragControls.start(e, {\n     *   snapToCursor: true\n     * })\n     * ```\n     *\n     * @param event - PointerEvent\n     * @param options - Options\n     *\n     * @public\n     */\n    DragControls.prototype.start = function (event, options) {\n        this.componentControls.forEach(function (controls) {\n            controls.start(event.nativeEvent || event, options);\n        });\n    };\n    DragControls.prototype.updateConstraints = function (flush) {\n        if (flush === void 0) { flush = true; }\n        this.componentControls.forEach(function (controls) {\n            controls.updateConstraints();\n        });\n        flush && flushLayout();\n    };\n    return DragControls;\n}());\nvar createDragControls = function () { return new DragControls(); };\n/**\n * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop\n * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we\n * might want to initiate that dragging from a different component than the draggable one.\n *\n * By creating a `dragControls` using the `useDragControls` hook, we can pass this into\n * the draggable component's `dragControls` prop. It exposes a `start` method\n * that can start dragging from pointer events on other components.\n *\n * @library\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <Frame onTapStart={startDrag} />\n *     <Frame drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @motion\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nfunction useDragControls() {\n    return useConstant(createDragControls);\n}\n\nvar createObject = function () { return ({}); };\nvar stateVisualElement = visualElement({\n    build: function () { },\n    measureViewportBox: axisBox,\n    resetTransform: function () { },\n    restoreTransform: function () { },\n    removeValueFromRenderState: function () { },\n    render: function () { },\n    scrapeMotionValuesFromProps: createObject,\n    readValueFromInstance: function (_state, key, options) {\n        return options.initialState[key] || 0;\n    },\n    makeTargetAnimatable: function (element, _a) {\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = tslib.__rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        checkTargetForNewValues(element, target, origin);\n        return tslib.__assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n});\nvar useVisualState = makeUseVisualState({\n    scrapeMotionValuesFromProps: createObject,\n    createRenderState: createObject,\n});\n/**\n * This is not an officially supported API and may be removed\n * on any version.\n * @internal\n */\nfunction useAnimatedState(initialState) {\n    var _a = tslib.__read(React.useState(initialState), 2), animationState = _a[0], setAnimationState = _a[1];\n    var visualState = useVisualState({}, false);\n    var element = useConstant(function () {\n        return stateVisualElement({ props: {}, visualState: visualState }, { initialState: initialState });\n    });\n    React.useEffect(function () {\n        element.mount({});\n        return element.unmount();\n    }, []);\n    React.useEffect(function () {\n        element.setProps({\n            onUpdate: function (v) { return setAnimationState(tslib.__assign({}, v)); },\n        });\n    });\n    var startAnimation = useConstant(function () { return function (animationDefinition) {\n        return animateVisualElement(element, animationDefinition);\n    }; });\n    return [animationState, startAnimation];\n}\n\n// Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\nvar maxScale = 100000;\nvar invertScale = function (scale) {\n    return scale > 0.001 ? 1 / scale : maxScale;\n};\nvar hasWarned = false;\n/**\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\n * of their respective parent scales.\n *\n * This is useful for undoing the distortion of content when scaling a parent component.\n *\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\n * of those instead.\n *\n * @motion\n *\n * ```jsx\n * const MyComponent = () => {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <motion.div style={{ scaleX, scaleY }} />\n * }\n * ```\n *\n * @library\n *\n * ```jsx\n * function MyComponent() {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <Frame scaleX={scaleX} scaleY={scaleY} />\n * }\n * ```\n *\n * @deprecated\n * @internal\n */\nfunction useInvertedScale(scale) {\n    var parentScaleX = useMotionValue(1);\n    var parentScaleY = useMotionValue(1);\n    var visualElement = useVisualElementContext();\n    heyListen.invariant(!!(scale || visualElement), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n    heyListen.warning(hasWarned, \"useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.\");\n    hasWarned = true;\n    if (scale) {\n        parentScaleX = scale.scaleX || parentScaleX;\n        parentScaleY = scale.scaleY || parentScaleY;\n    }\n    else if (visualElement) {\n        parentScaleX = visualElement.getValue(\"scaleX\", 1);\n        parentScaleY = visualElement.getValue(\"scaleY\", 1);\n    }\n    var scaleX = useTransform(parentScaleX, invertScale);\n    var scaleY = useTransform(parentScaleY, invertScale);\n    return { scaleX: scaleX, scaleY: scaleY };\n}\n\nexports.AnimatePresence = AnimatePresence;\nexports.AnimateSharedLayout = AnimateSharedLayout;\nexports.DragControls = DragControls;\nexports.FlatTree = FlatTree;\nexports.FramerTreeLayoutContext = FramerTreeLayoutContext;\nexports.LayoutGroupContext = LayoutGroupContext;\nexports.LazyMotion = LazyMotion;\nexports.MotionConfig = MotionConfig;\nexports.MotionConfigContext = MotionConfigContext;\nexports.MotionValue = MotionValue;\nexports.PresenceContext = PresenceContext;\nexports.SharedLayoutContext = SharedLayoutContext;\nexports.addScaleCorrection = addScaleCorrection;\nexports.animate = animate;\nexports.animateVisualElement = animateVisualElement;\nexports.animationControls = animationControls;\nexports.batchLayout = batchLayout;\nexports.createBatcher = createBatcher;\nexports.createCrossfader = createCrossfader;\nexports.createDomMotionComponent = createDomMotionComponent;\nexports.createMotionComponent = createMotionComponent;\nexports.domAnimation = domAnimation;\nexports.domMax = domMax;\nexports.flushLayout = flushLayout;\nexports.isValidMotionProp = isValidMotionProp;\nexports.m = m;\nexports.motion = motion;\nexports.motionValue = motionValue;\nexports.resolveMotionValue = resolveMotionValue;\nexports.snapshotViewportBox = snapshotViewportBox;\nexports.transform = transform;\nexports.useAnimation = useAnimation;\nexports.useCycle = useCycle;\nexports.useDeprecatedAnimatedState = useAnimatedState;\nexports.useDeprecatedInvertedScale = useInvertedScale;\nexports.useDomEvent = useDomEvent;\nexports.useDragControls = useDragControls;\nexports.useElementScroll = useElementScroll;\nexports.useIsPresent = useIsPresent;\nexports.useMotionTemplate = useMotionTemplate;\nexports.useMotionValue = useMotionValue;\nexports.usePresence = usePresence;\nexports.useReducedMotion = useReducedMotion;\nexports.useSpring = useSpring;\nexports.useTransform = useTransform;\nexports.useVelocity = useVelocity;\nexports.useViewportScroll = useViewportScroll;\nexports.visualElement = visualElement;\n\n\n/***/ })\n\n}]);"],"names":["self","push","__unused_webpack_module","exports","__webpack_require__","Object","defineProperty","value","AnimationType","lastPointerEvent","Presence","BoundingBoxDimension","viewportScrollValues","prefersReducedMotion","tslib","React","heyListen","styleValueTypes","popmotion","sync","_interopDefaultLegacy","e","React__namespace","_interopNamespace","__esModule","n","create","keys","forEach","k","d","getOwnPropertyDescriptor","get","enumerable","freeze","React__default","sync__default","createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","layoutAnimation","loadFeatures","features","key","Component","LazyContext","createContext","strict","featureNames","numFeatures","length","MotionConfigContext","transformPagePoint","p","isStatic","MotionContext","useVisualElementContext","useContext","visualElement","PresenceContext","useConstant","init","ref","useRef","current","usePresence","context","isPresent","onExitComplete","register","id","useUniqueId","useEffect","safeToRemove","counter","incrementId","LayoutGroupContext","isBrowser","window","useIsomorphicLayoutEffect","useLayoutEffect","isRefObject","prototype","hasOwnProperty","call","isVariantLabels","v","Array","isArray","isVariantLabel","resolveVariantFromProps","definition","custom","currentValues","currentVelocity","_a","variants","resolveVariant","velocity","getProps","forEachValue","getVelocity","checkIfControllingVariants","animate","start","initial","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","Boolean","variantLabelsAsDependency","prop","join","createMotionComponent","preloadedFeatures","createVisualElement","useRender","useVisualState","forwardRef","externalRef","visualState","config","lazyContext","parent","presenceContext","layoutId","layoutGroupId","visualElementRef","getCurrentTreeVariants","undefined","inherit","useMemo","renderer","__assign","presenceId","blockInitialAnimation","setProps","isPresenceRoot","syncRender","animationState","animateChanges","notifyUnmount","useFeatures","i","name_1","createElement","Fragment","Provider","useCallback","instance","mount","unmount","createMotionProxy","createConfig","customMotionComponentConfig","componentCache","Map","Proxy","_target","has","set","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","valueScaleCorrection","addScaleCorrection","correctors","transformAxes","transformProps","sortTransformProps","a","b","operationKey","axesKey","transformPropSet","Set","isTransformProp","transformOriginProps","isTransformOriginProp","isForcedMotionValue","layout","isMotionValue","translateAlias","x","y","z","transformPerspective","isCSSVariable$1","startsWith","int","number","transform","Math","round","numberValueTypes","borderWidth","px","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","degrees","rotateX","rotateY","rotateZ","scale","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","opacity","alpha","originX","progressPercentage","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","buildHTMLStyles","state","latestValues","projection","layoutState","options","transformTemplate","buildProjectionTransform","buildProjectionTransformOrigin","_b","_c","_d","style","vars","transformKeys","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","type","valueType","valueAsType","default","isHydrated","correctedValue","process","applyTo","num","deltaFinal","treeScale","buildTransform","transformIsDefault","enableHardwareAcceleration","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","trim","createHtmlRenderState","copyRawValuesOnly","target","source","useHTMLProps","styleProp","htmlProps","assign","transformValues","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","validMotionProps","isValidMotionProp","shouldForward","emotionIsPropValid_1","Z","calcOrigin$1","origin","offset","progressToPixels","progress","dashKeys","array","camelKeys","buildSVGAttrs","dimensions","pxOriginX","pxOriginY","attrs","totalLength","spacing","useDashCase","pathLength","pathSpacing","attrX","attrY","pathOffset","__rest","totalPathLength","createSvgRenderState","useSVGProps","visualProps","rawStyles","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","renderHTML","element","setProperty","camelCaseAttributes","renderSVG","renderState","setAttribute","scrapeMotionValuesFromProps$1","newValues","scrapeMotionValuesFromProps","toUpperCase","isAnimationControls","isKeyframesTarget","resolveMotionValue","unwrappedValue","isCustomValue","mix","toValue","makeState","createRenderState","onMount","makeLatestValues","makeUseVisualState","scrapeMotionValues","values","motionValues","isControllingVariants","isVariantNode","variantToSet","list","resolved","transitionEnd","transition","svgMotionConfig","getBBox","getBoundingClientRect","getTotalLength","isPath","tagName","htmlMotionConfig","createDomMotionConfig","forwardMotionProps","baseConfig","useVisualProps","filteredProps","filterProps","isDom","elementProps","addDomEvent","eventName","handler","addEventListener","removeEventListener","useDomEvent","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","extractEventInfo","pointType","point","primaryTouch","changedTouches","wrapHandler","shouldFilterPrimaryPointer","eventHandler","listener","button","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","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","makeRenderlessComponent","hook","gestureAnimations","onTap","onTapStart","onTapCancel","isPressing","cancelPointerEndListeners","removePointerEndListener","checkPointerEnd","Tap","onPointerUp","getInstance","onPointerCancel","hasPressListeners","pipe","Focus","onHoverStart","onHoverEnd","shallowCompare","next","prev","prevLength","secondsToMilliseconds","seconds","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","invariant","__read","x1","y1","x2","y2","cubicBezier","isAnimatable","complex","underDampedSpring","stiffness","damping","restDelta","restSpeed","criticallyDampedSpring","to","sqrt","linearTween","ease","duration","defaultTransitions","backgroundColor","color","getDefaultTransition","valueKey","transitionFactory","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","filter","WebkitFilter","getDefaultValueType","getAnimatableNone","defaultValueType","legacyRepeatWarning","isZero","parseFloat","getZeroUnit","potentialUnitType","getValueTransition","startAnimation","onComplete","valueTransition","isTargetAnimatable","isOriginAnimatable","delayTimer","controls","from","warning","times","yoyo","flip","loop","onUpdate","inertia","__spreadArray","when","delay","delayChildren","staggerChildren","staggerDirection","repeat","repeatType","repeatDelay","isEasingArray","map","stop","setTimeout","clearTimeout","addUniqueItem","arr","item","removeItem","index","splice","SubscriptionManager","subscriptions","add","_this","notify","c","numSubscriptions","getSize","clear","MotionValue","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","render","getFrameData","delta","timestamp","postRender","scheduleVelocityCheck","velocityCheck","hasAnimated","isNaN","onChange","subscription","clearListeners","onRenderRequest","attach","passiveEffect","getPrevious","velocityPerSecond","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","motionValue","testValueType","dimensionValueTypes","percent","vw","vh","parse","findDimensionValueType","find","valueTypes","setMotionValue","hasValue","getValue","addValue","setTarget","makeTargetAnimatable","setVariants","variantLabels","reversedLabels","reverse","variant","getVariant","variantChildren","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","getOrigin","animateVisualElement","notifyAnimationStart","animations","animateVariant","all","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getAnimation","getChildAnimations","forwardDelay","animateChildren","first","last","_e","_f","animationTypeState","getState","valueTarget","shouldBlockAnimation","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","variantPriorityOrder","Animate","Drag","Exit","reversePriorityOrder","numAnimationTypes","createTypeState","prevResolvedValues","createAnimationState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","shouldAnimateType","variantsHaveChanged","definitionList","resolvedValues","reduce","allKeys","markToAnimate","delete","apply","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","isAnimated","setAnimateFunction","makeAnimator","subscribe","PanSession","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","update","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","cancelSync","subtractPoint","lastDevicePoint","startDevicePoint","timestampedPoint","lastPoint","time","noop","any","convertBoundingBoxToAxisBox","min","max","axisBox","zeroDelta","translate","originPoint","eachAxis","isNear","maxDistance","calcLength","axis","updateAxisDelta","updateBoxDelta","defaultOrigin","calcRelativeAxis","relative","applyConstraints","elastic","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","getBoundingBox","topLeft","bottomRight","compareByDepth","depth","isProjecting","shouldResetTransform","collectProjectingAncestors","ancestors","updateLayoutMeasurement","box","getLayoutState","notifyBeforeLayoutMeasure","measureViewportBox","layoutCorrected","notifyLayoutMeasure","prevViewportBox","rebaseProjectionTarget","snapshotViewportBox","calcRelativeOffsetAxis","calcRelativeOffset","isDraggable","_dragX","resetAxis","originAxis","applyPointDelta","boxScale","scalePoint","applyAxisDelta","applyBoxDelta","applyAxisTransforms","final","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","applyBoxTransforms","finalBox","removePointDelta","removeAxisTransforms","removeBoxTransforms","unresolvedJobs","pushJob","stack","job","pointer","batchLayout","flushLayout","reads","writes","setRead","setWrite","numStacks","executeJob","elementDragControls","WeakMap","VisualElementDragControls","isDragging","currentDirection","constraints","hasMutatedConstraints","cursorProgress","openGlobalLock","panSession","enableLayoutProjection","originEvent","snapToCursor","stopMotion","initialPoint","getViewportPointFromEvent","cancelLayout","read","write","children","addChild","tree","hasManuallySetCursorOrigin","isLayoutDrag","lockProjectionTarget","resetTransform","restoreTransform","getAxisMotionValue","isExternalDrag","scheduleUpdateLayoutProjection","axisValue","flushSync","preRender","resolveDragConstraints","dragPropagation","onDragStart","dragDirectionLock","getCurrentDirection","onDirectionLock","updateAxis","onDrag","layoutBox","dragConstraints","resolveRefConstraints","relativeConstraints","constraintsBox","onMeasureDragConstraints","constraintsElement","measuredConstraints","userConstraints","cancelDrag","unlockProjectionTarget","animateDragEnd","onDragEnd","shouldDrag","length_1","center","updateAxisMotionValue","updateVisualElementAxis","nextValue","axisLayout","axisLength","axisProgress","setProjectionTargetAxis","_g","dragMomentum","remainingProps","dragKey","_dragY","projectionParent","dragTransition","isRelative","getProjectionParent","getLatestValues","relativeConstraints_1","targetFinal","momentumAnimations","bounceStiffness","bounceDamping","timeConstant","startAxisValueAnimation","startLayoutAnimation","onDragTransitionEnd","stopLayoutAnimation","currentValue","boxProgress","sourceLength","targetLength","clamp","updateConstraints","onReady","stopPointerListener","dragListener","stopResizeListener","stopLayoutUpdateListener","onLayoutUpdate","prevDragCursor","direction","lockThreshold","abs","VisibilityAction","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","groupDragControls","dragControls","isCSSVariable","cssVariableRegex","getVariableValue","parseCSSVariable","match","exec","token","fallback","getComputedStyle","getPropertyValue","pixelsToPercent","pixels","varToken","borderCorrectionDefinition","latest","_layoutState","defaultScaleCorrectors","boxShadow","original","containsCSSVariables","cssVariables","shadow","template","createTransformer","xScale","yScale","averageScale","output","i_1","cssVariable","_super","arguments","frameTarget","currentAnimationTarget","stopAxisAnimation","isAnimatingTree","originBox","targetBox","visibilityAction","shouldStackAnimate","prevParent","prevId","nextId","prevParentViewportBox","parentLayout","getLayoutId","isProvidedCorrectDataForRelativeSharedLayout","boxHasMoved","hasMoved","isTargetLocked","setVisibility","Show","animateAxis","notifyLayoutAnimationComplete","__extends","componentDidMount","animateMotionValue","unsubLayoutReady","layoutSafeToRemove","componentWillUnmount","axisIsEqual","layoutProgress","getProjectionAnimationProgress","frame","unsubscribeProgress","layoutTransition","defaultLayoutTransition","isZeroBox","zeroAxis","defaultHandler","layoutReady","notifyLayoutReady","createBatcher","queue","flush","order","allElements","presence","Present","assignProjectionToSnapshot","SharedLayoutContext","FramerTreeLayoutContext","isSharedLayout","forceUpdate","Measure","syncLayout","framerSyncLayout","onUnmount","remove","getSnapshotBeforeUpdate","syncUpdate","componentDidUpdate","layoutAnimations","createLayoutState","deltaTransform","zeroLayout","buildLayoutProjectionTransform","latestTransform","identityProjection","buildLayoutProjectionTransformOrigin","names","FlatTree","isDirty","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","unsubscribeFromLeadVisualElement","crossfader","projectionTargetProgress","removeFromVariantTree","managers","propSubscriptions","lifecycles","clearAllListeners","manager","updatePropListeners","on","propListener","args","_i","leadProjection","leadLatestValues","hasViewportBoxUpdated","valueSubscriptions","prevMotionValues","baseTarget","isProjectionReady","triggerBuild","valuesToRender","crossfadedValues","getCrossfadeState","notifyUpdate","updateTreeLayoutProjection","layoutTree","fireUpdateLayoutProjection","initialMotionValues","path","isVisible","isMounted","newInstance","pointTo","addVariantChild","updateLayoutProjection","closestVariantNode","getClosestVariantNode","other","getStaticValue","setStaticValue","visibility","scheduleRender","canMutate","removeOnChange","removeOnRenderRequest","removeValue","latestValue","defaultValue","newProps","updateMotionValuesFromProps","prevValue","existingValue","startAtParent","context_1","numVariantProps","variantProps","setCrossfader","newCrossfader","relativeTarget","withTransform","viewportBox","notifySetAxisTarget","force","shouldRebase","setCurrentViewportBox","relativeOffset","notifyLayoutUpdate","treePath","prevTreeScaleX","prevTreeScaleY","prevDeltaTransform","applyTreeDeltas","node","treeLength","notifyViewportBoxUpdate","fireResolveRelativeTargetBox","foundParent","ancestor","resolveRelativeTargetBox","parentProjection","relativeParent","_layoutResetTransform","newLead","onSetAxisTarget","onLayoutAnimationComplete","Entering","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","positionalValues","convertChangedValueTypes","changedKeys","originBbox","elementComputedStyle","display","originComputedStyle","targetBbox","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","removedTransforms","convertedTarget","parseDomVariant","resolveCSSVariables","HTMLElement","hasPositionalKey","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","mutableState","parsed","isProjectionTranform","htmlVisualElement","svgVisualElement","getAttribute","_element","createDomVisualElement","featureBundle","motion","m","getPresenceId","PresenceChild","presenceAffectsLayout","presenceChildren","newChildrenMap","childId","allComplete","isComplete","_","getChildKey","createCrossfader","lead","follow","crossfadeOpacity","preserveFollowOpacity","prevOptions","leadState","followState","finalCrossfadeFrame","prevUpdate","startCrossfadeAnimation","hasUpdated","fromLead","toLead","initialProgress","prevValues","reset","updateCrossfade","latestLeadValues","latestFollowValues","leadTargetOpacity","followTargetOpacity","easeCrossfadeIn","easeCrossfadeOut","mixValues","setOptions","newOptions","compress","easing","borders","numBorders","hasFollowElement","borderLabel","followRadius","getRadius","leadRadius","mixColor","radiusName","AnimateSharedLayout","stacks","hasMounted","updateScheduled","renderScheduled","syncContext","scheduleUpdate","removeChild","shouldComponentUpdate","Exiting","updateStacks","getStack","clearSnapshot","updateLeadAndFollow","resetRotate","hasRotate","resetValues","updateSnapshot","addToStack","removeFromStack","prevState","needsCrossfadeAnimation","leadIsExiting","getLead","shouldCrossfade","contextType","isLazyBundle","domAnimation","domMax","useMotionValue","setLatest_1","useState","useOnChange","useCombineMotionValues","combineValues","updateValue","useMultiOnChange","unsubscribe","getMixer","isCustomValueType","useImmediate","argOffset","inputValue","inputRange","outputRange","interpolator","interpolate","mixer","useTransform","input","inputRangeOrTransformer","transformer","useListTransform","numValues","createScrollMotionValues","scrollX","scrollY","scrollXProgress","scrollYProgress","setProgress","maxOffset","createScrollUpdater","getOffsets","xOffset","yOffset","xMaxOffset","yMaxOffset","getViewportScrollOffsets","pageXOffset","pageYOffset","document","body","clientWidth","innerWidth","clientHeight","innerHeight","hasListeners","animationControls","pendingAnimations","subscribers","animations_1","DragControls","componentControls","nativeEvent","createDragControls","createObject","stateVisualElement","_state","initialState","invertScale","hasWarned","AnimatePresence","unloadingRef","forcedRenderCount","setForcedRenderCount","exitBeforeEnter","forceRender","layoutContext","filtered","filteredChildren","Children","isValidElement","presentChildren","allChildren","exiting","updateChildLookup","childrenToRender","presentKeys","targetKeys","numPresent","insertionIndex","onExit","removeIndex","findIndex","presentChild","cloneElement","LazyMotion","setIsLoaded","loadedRenderer","loadedFeatures","MotionConfig","transitionDependency","toString","createDomMotionComponent","useAnimation","useCycle","items","setItem","wrap","useDeprecatedAnimatedState","setAnimationState","animationDefinition","useDeprecatedInvertedScale","parentScaleX","parentScaleY","useDragControls","useElementScroll","updateScrollValues","scrollLeft","scrollTop","scrollWidth","offsetWidth","scrollHeight","offsetHeight","scrollListener","passive","resizeListener","useIsPresent","useMotionTemplate","fragments","numFragments","useReducedMotion","initPrefersReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","shouldReduceMotion","setShouldReduceMotion","useSpring","activeSpringAnimation","useVelocity","newVelocity","useViewportScroll","addEventListeners"],"sourceRoot":""}