{"version":3,"file":"bd1a647f-a8585a05c6891d2c4567.js","mappings":"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","sources":["webpack://gatsby-starter-default/./node_modules/framer-motion/dist/cjs/index.js"],"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');\nvar dom = require('@motionone/dom');\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 () { return e[k]; }\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\n/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nvar createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\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 (env !== \"production\" && preloadedFeatures && 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    reducedMotion: \"never\",\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\nvar isBrowser = typeof document !== \"undefined\";\n\nvar useIsomorphicLayoutEffect = isBrowser ? React.useLayoutEffect : React.useEffect;\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = tslib.__read(React.useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = React.useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = React.useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = React.useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\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: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    React.useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\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    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity$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) {\n    var _a = getCurrentTreeVariants(props, React.useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return React.useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\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 * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nvar id$1 = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id$1++;\n        }\n    });\n}\n\nvar LayoutGroupContext = React.createContext({});\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = React.createContext({});\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = React.useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.scheduleRender(); },\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    tslib.__extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default[\"default\"].Component));\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = tslib.__assign(tslib.__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = React.useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, tslib.__assign(tslib.__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React__namespace.createElement(VisualElementHandler, { visualElement: context.visualElement, props: tslib.__assign(tslib.__assign({}, config), props) },\n            features,\n            React__namespace.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return React.forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = React.useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\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    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    var componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: function (_target, key) {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\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 scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\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            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nvar isMotionValue = function (value) {\n    return Boolean(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 += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\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, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable$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            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\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, { 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) && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\n/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    var filteredProps = {};\n    for (var key in props) {\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\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 \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = styleValueTypes.px.transform(-offset);\n    // Build the dash array\n    var pathLength = styleValueTypes.px.transform(length);\n    var pathSpacing = styleValueTypes.px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = tslib.__rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\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, { 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, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = tslib.__assign(tslib.__assign(tslib.__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\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, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\n/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\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 */\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) {\n    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 () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = tslib.__rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\n            try {\n                renderState.dimensions =\n                    typeof instance.getBBox ===\n                        \"function\"\n                        ? instance.getBBox()\n                        : instance.getBoundingClientRect();\n            }\n            catch (e) {\n                // Most likely trying to measure an unrendered element under Firefox\n                renderState.dimensions = {\n                    x: 0,\n                    y: 0,\n                    width: 0,\n                    height: 0,\n                };\n            }\n            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return tslib.__assign(tslib.__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexports.AnimationType = void 0;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(exports.AnimationType || (exports.AnimationType = {}));\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    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(exports.AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.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}\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        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\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    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.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, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nvar warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = tslib.__rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, tslib.__assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = React.useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    React.useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    React.useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nvar makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\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 useId when released in React\n    var id = useId();\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}\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 '\".concat(definition, \"'\"));\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\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    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\n}); };\nvar defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return 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\nvar instantAnimationState = {\n    current: false,\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, _b;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = tslib.__spreadArray([], tslib.__read(options.to), false);\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = 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 \".concat(key, \" from \\\"\").concat(origin, \"\\\" to \\\"\").concat(target, \"\\\". \").concat(origin, \" is not an animatable value - to enable this animation set \").concat(origin, \" to a value animatable to \").concat(target, \" via the `style` property.\"));\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? 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, _b;\n        var finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);\n        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = window.setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\n}\n\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\n/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nfunction addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_a, fromIndex, toIndex) {\n    var _b = tslib.__read(_a), arr = _b.slice(0);\n    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        var _c = tslib.__read(arr.splice(fromIndex, 1), 1), item = _c[0];\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\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         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"6.5.1\";\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = 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     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @privateRemarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\n    };\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\n        return this.prev;\n    };\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                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}());\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), false), [styleValueTypes.color, styleValueTypes.complex], false);\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 ? visualElement.makeTargetAnimatable(resolved, false) : {}, _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), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && 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\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return Promise.resolve(); };\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return Promise.resolve(); };\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    var when = transition.when;\n    if (when) {\n        var _c = 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 valueTransition = tslib.__assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = tslib.__assign(tslib.__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, 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    exports.AnimationType.Animate,\n    exports.AnimationType.InView,\n    exports.AnimationType.Focus,\n    exports.AnimationType.Hover,\n    exports.AnimationType.Tap,\n    exports.AnimationType.Drag,\n    exports.AnimationType.Exit,\n];\nvar reversePriorityOrder = tslib.__spreadArray([], tslib.__read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = 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 variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = 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) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = 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                }); })), false));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = 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        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[exports.AnimationType.Animate] = createTypeState(true),\n        _a[exports.AnimationType.InView] = createTypeState(),\n        _a[exports.AnimationType.Hover] = createTypeState(),\n        _a[exports.AnimationType.Tap] = createTypeState(),\n        _a[exports.AnimationType.Drag] = createTypeState(),\n        _a[exports.AnimationType.Focus] = createTypeState(),\n        _a[exports.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], safeToRemove = _a[1];\n        var presenceContext = React.useContext(PresenceContext);\n        React.useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\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 calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return popmotion.distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = popmotion.mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        popmotion.mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\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 * 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 { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = 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 popmotion.clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nvar createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nfunction eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\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 convertBoundingBoxToBox(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nfunction isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    var distanceFromOrigin = point - originPoint;\n    var scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, _a) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = popmotion.mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys$1 = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys$1 = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys$1);\n    transformAxis(box.y, transform, yKeys$1);\n}\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (styleValueTypes.percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(exports.AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        heyListen.invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = tslib.__assign(tslib.__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - popmotion.mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(popmotion.mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return tslib.__assign(tslib.__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    React.useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    React.useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = 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\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, tslib.__spreadArray([], tslib.__read(args), false));\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             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = 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         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync__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             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                sync.cancelSync.update(update);\n                sync.cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            }, \n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\n            }, \n            /**\n             * Measure the current viewport box with or without transforms.\n             * Only measures axis-aligned boxes, rotate and skew must be manually\n             * removed with a re-render to work.\n             */\n            measureViewportBox: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \n            /**\n             * If we're trying to animate to a previously unencountered value,\n             * we need to check for it in our state and as a last resort read it\n             * directly from the instance (which might have performance implications).\n             */\n            readValue: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n            }, \n            /**\n             * Set the base target to later animate back to. This is currently\n             * only hydrated on creation and when we first read a value.\n             */\n            setBaseTarget: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync__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                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = tslib.__spreadArray([\"initial\"], tslib.__read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\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 \\\"\".concat(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 Element))\n        return { target: target, transitionEnd: transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = 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\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) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (key) {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = 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 fromType = findDimensionValueType(from);\n        var to = target[key];\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    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 =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = 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        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\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 measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = 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, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nvar svgVisualElement = visualElement(tslib.__assign(tslib.__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (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, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = 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 = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = 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    },\n};\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    tslib.__extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(tslib.__assign(tslib.__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync__default[\"default\"].postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default[\"default\"].Component));\nfunction MeasureLayout(props) {\n    var _a = tslib.__read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = React.useContext(LayoutGroupContext);\n    return (React__default[\"default\"].createElement(MeasureLayoutWithContext, tslib.__assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: React.useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: tslib.__assign(tslib.__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\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        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || styleValueTypes.px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = popmotion.mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = popmotion.mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = popmotion.mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(popmotion.mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (styleValueTypes.percent.test(leadRadius) || styleValueTypes.percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = popmotion.mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, 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}\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (styleValueTypes.percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = popmotion.mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = popmotion.mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a, origin, sourceAxis) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nfunction isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nvar identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nvar compareByDepth = function (a, b) {\n    return a.depth - b.depth;\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\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, tslib.__spreadArray([], tslib.__read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = tslib.__assign(tslib.__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            sync.cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            sync.flushSync.update();\n            sync.flushSync.preRender();\n            sync.flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync__default[\"default\"].preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync__default[\"default\"].postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = tslib.__assign(tslib.__assign(tslib.__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = tslib.__assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                sync.cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync__default[\"default\"].update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, tslib.__assign(tslib.__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = popmotion.mix(delta.translate, 0, p);\n    output.scale = popmotion.mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = popmotion.mix(from.min, to.min, p);\n    output.max = popmotion.mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nvar featureBundle = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, animations), gestureAnimations), drag), layoutFeatures);\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nvar motion = /*@__PURE__*/ createMotionProxy(function (Component, config) {\n    return createDomMotionConfig(Component, config, featureBundle, createDomVisualElement, HTMLProjectionNode);\n});\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, featureBundle, createDomVisualElement, HTMLProjectionNode));\n}\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nfunction useIsMounted() {\n    var isMounted = React.useRef(false);\n    useIsomorphicLayoutEffect(function () {\n        isMounted.current = true;\n        return function () {\n            isMounted.current = false;\n        };\n    }, []);\n    return isMounted;\n}\n\nfunction useForceUpdate() {\n    var isMounted = useIsMounted();\n    var _a = tslib.__read(React.useState(0), 2), forcedRenderCount = _a[0], setForcedRenderCount = _a[1];\n    var forceRender = React.useCallback(function () {\n        isMounted.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n    /**\n     * Defer this to the end of the next animation frame in case there are multiple\n     * synchronous calls.\n     */\n    var deferredForceRender = React.useCallback(function () { return sync__default[\"default\"].postRender(forceRender); }, [forceRender]);\n    return [deferredForceRender, forcedRenderCount];\n}\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 = useId();\n    var context = React.useMemo(function () { return ({\n        id: id,\n        initial: initial,\n        isPresent: isPresent,\n        custom: custom,\n        onExitComplete: function (childId) {\n            var e_1, _a;\n            presenceChildren.set(childId, true);\n            try {\n                for (var _b = tslib.__values(presenceChildren.values()), _c = _b.next(); !_c.done; _c = _b.next()) {\n                    var isComplete = _c.value;\n                    if (!isComplete)\n                        return; // can stop searching when any is incomplete\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            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\nvar getChildKey = function (child) { return child.key || \"\"; };\nfunction updateChildLookup(children, allChildren) {\n    children.forEach(function (child) {\n        var key = getChildKey(child);\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 * 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 _d = tslib.__read(useForceUpdate(), 1), forceRender = _d[0];\n    var forceRenderLayoutGroup = React.useContext(LayoutGroupContext).forceRender;\n    if (forceRenderLayoutGroup)\n        forceRender = forceRenderLayoutGroup;\n    var isMounted = useIsMounted();\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    var filteredChildren = onlyElements(children);\n    var childrenToRender = filteredChildren;\n    var exiting = new Set();\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(childrenToRender);\n    // A lookup table to quickly reference components by key\n    var allChildren = React.useRef(new Map()).current;\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    var isInitialRender = React.useRef(true);\n    useIsomorphicLayoutEffect(function () {\n        isInitialRender.current = false;\n        updateChildLookup(filteredChildren, allChildren);\n        presentChildren.current = childrenToRender;\n    });\n    useUnmountEffect(function () {\n        isInitialRender.current = true;\n        allChildren.clear();\n        exiting.clear();\n    });\n    if (isInitialRender.current) {\n        return (React__namespace.createElement(React__namespace.Fragment, null, childrenToRender.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    childrenToRender = tslib.__spreadArray([], tslib.__read(childrenToRender), false);\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    }\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                if (isMounted.current === false)\n                    return;\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    if (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 * @deprecated\n */\nvar DeprecatedLayoutGroupContext = React.createContext(null);\n\nvar notify = function (node) {\n    return !node.isLayoutDirty && node.willUpdate(false);\n};\nfunction nodeGroup() {\n    var nodes = new Set();\n    var subscriptions = new WeakMap();\n    var dirtyAll = function () { return nodes.forEach(notify); };\n    return {\n        add: function (node) {\n            nodes.add(node);\n            subscriptions.set(node, node.addEventListener(\"willUpdate\", dirtyAll));\n        },\n        remove: function (node) {\n            var _a;\n            nodes.delete(node);\n            (_a = subscriptions.get(node)) === null || _a === void 0 ? void 0 : _a();\n            subscriptions.delete(node);\n            dirtyAll();\n        },\n        dirty: dirtyAll,\n    };\n}\n\nvar shouldInheritGroup = function (inherit) { return inherit === true; };\nvar shouldInheritId = function (inherit) {\n    return shouldInheritGroup(inherit === true) || inherit === \"id\";\n};\nvar LayoutGroup = function (_a) {\n    var _b, _c;\n    var children = _a.children, id = _a.id, inheritId = _a.inheritId, _d = _a.inherit, inherit = _d === void 0 ? true : _d;\n    // Maintain backwards-compatibility with inheritId until 7.0\n    if (inheritId !== undefined)\n        inherit = inheritId;\n    var layoutGroupContext = React.useContext(LayoutGroupContext);\n    var deprecatedLayoutGroupContext = React.useContext(DeprecatedLayoutGroupContext);\n    var _e = tslib.__read(useForceUpdate(), 2), forceRender = _e[0], key = _e[1];\n    var context = React.useRef(null);\n    var upstreamId = (_b = layoutGroupContext.id) !== null && _b !== void 0 ? _b : deprecatedLayoutGroupContext;\n    if (context.current === null) {\n        if (shouldInheritId(inherit) && upstreamId) {\n            id = id ? upstreamId + \"-\" + id : upstreamId;\n        }\n        context.current = {\n            id: id,\n            group: shouldInheritGroup(inherit)\n                ? (_c = layoutGroupContext === null || layoutGroupContext === void 0 ? void 0 : layoutGroupContext.group) !== null && _c !== void 0 ? _c : nodeGroup()\n                : nodeGroup(),\n        };\n    }\n    var memoizedContext = React.useMemo(function () { return (tslib.__assign(tslib.__assign({}, context.current), { forceRender: forceRender })); }, [key]);\n    return (React__namespace.createElement(LayoutGroupContext.Provider, { value: memoizedContext }, children));\n};\n\nvar id = 0;\nvar AnimateSharedLayout = function (_a) {\n    var children = _a.children;\n    React__namespace.useEffect(function () {\n        heyListen.warning(false, \"AnimateSharedLayout is deprecated: https://www.framer.com/docs/guide-upgrade/##shared-layout-animations\");\n    }, []);\n    return (React__namespace.createElement(LayoutGroup, { id: useConstant(function () { return \"asl-\".concat(id++); }) }, children));\n};\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, isValidProp = _a.isValidProp, config = tslib.__rest(_a, [\"children\", \"isValidProp\"]);\n    isValidProp && loadExternalIsValidProp(isValidProp);\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 context = React.useMemo(function () { return config; }, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);\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\nvar ReorderContext = React.createContext(null);\n\nfunction checkReorder(order, value, offset, velocity) {\n    if (!velocity)\n        return order;\n    var index = order.findIndex(function (item) { return item.value === value; });\n    if (index === -1)\n        return order;\n    var nextOffset = velocity > 0 ? 1 : -1;\n    var nextItem = order[index + nextOffset];\n    if (!nextItem)\n        return order;\n    var item = order[index];\n    var nextLayout = nextItem.layout;\n    var nextItemCenter = popmotion.mix(nextLayout.min, nextLayout.max, 0.5);\n    if ((nextOffset === 1 && item.layout.max + offset > nextItemCenter) ||\n        (nextOffset === -1 && item.layout.min + offset < nextItemCenter)) {\n        return moveItem(order, index, index + nextOffset);\n    }\n    return order;\n}\n\nfunction ReorderGroup(_a, externalRef) {\n    var children = _a.children, _b = _a.as, as = _b === void 0 ? \"ul\" : _b, _c = _a.axis, axis = _c === void 0 ? \"y\" : _c, onReorder = _a.onReorder, values = _a.values, props = tslib.__rest(_a, [\"children\", \"as\", \"axis\", \"onReorder\", \"values\"]);\n    var Component = useConstant(function () { return motion(as); });\n    var order = [];\n    var isReordering = React.useRef(false);\n    heyListen.invariant(Boolean(values), \"Reorder.Group must be provided a values prop\");\n    var context = {\n        axis: axis,\n        registerItem: function (value, layout) {\n            /**\n             * Ensure entries can't add themselves more than once\n             */\n            if (layout &&\n                order.findIndex(function (entry) { return value === entry.value; }) === -1) {\n                order.push({ value: value, layout: layout[axis] });\n                order.sort(compareMin);\n            }\n        },\n        updateOrder: function (id, offset, velocity) {\n            if (isReordering.current)\n                return;\n            var newOrder = checkReorder(order, id, offset, velocity);\n            if (order !== newOrder) {\n                isReordering.current = true;\n                onReorder(newOrder\n                    .map(getValue)\n                    .filter(function (value) { return values.indexOf(value) !== -1; }));\n            }\n        },\n    };\n    React.useEffect(function () {\n        isReordering.current = false;\n    });\n    return (React__namespace.createElement(Component, tslib.__assign({}, props, { ref: externalRef }),\n        React__namespace.createElement(ReorderContext.Provider, { value: context }, children)));\n}\nvar Group = React.forwardRef(ReorderGroup);\nfunction getValue(item) {\n    return item.value;\n}\nfunction compareMin(a, b) {\n    return a.layout.min - b.layout.min;\n}\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 * ```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\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 useOnChange(value, callback) {\n    useIsomorphicLayoutEffect(function () {\n        if (isMotionValue(value))\n            return value.onChange(callback);\n    }, [callback]);\n}\nfunction useMultiOnChange(values, handler) {\n    useIsomorphicLayoutEffect(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\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\nfunction useDefaultMotionValue(value, defaultValue) {\n    if (defaultValue === void 0) { defaultValue = 0; }\n    return isMotionValue(value) ? value : useMotionValue(defaultValue);\n}\nfunction ReorderItem(_a, externalRef) {\n    var children = _a.children, style = _a.style, value = _a.value, _b = _a.as, as = _b === void 0 ? \"li\" : _b, onDrag = _a.onDrag, _c = _a.layout, layout = _c === void 0 ? true : _c, props = tslib.__rest(_a, [\"children\", \"style\", \"value\", \"as\", \"onDrag\", \"layout\"]);\n    var Component = useConstant(function () { return motion(as); });\n    var context = React.useContext(ReorderContext);\n    var point = {\n        x: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.x),\n        y: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.y),\n    };\n    var zIndex = useTransform([point.x, point.y], function (_a) {\n        var _b = tslib.__read(_a, 2), latestX = _b[0], latestY = _b[1];\n        return latestX || latestY ? 1 : \"unset\";\n    });\n    var measuredLayout = React.useRef(null);\n    heyListen.invariant(Boolean(context), \"Reorder.Item must be a child of Reorder.Group\");\n    var _d = context, axis = _d.axis, registerItem = _d.registerItem, updateOrder = _d.updateOrder;\n    React.useEffect(function () {\n        registerItem(value, measuredLayout.current);\n    }, [context]);\n    return (React__namespace.createElement(Component, tslib.__assign({ drag: axis }, props, { dragSnapToOrigin: true, style: tslib.__assign(tslib.__assign({}, style), { x: point.x, y: point.y, zIndex: zIndex }), layout: layout, onDrag: function (event, gesturePoint) {\n            var velocity = gesturePoint.velocity;\n            velocity[axis] &&\n                updateOrder(value, point[axis].get(), velocity[axis]);\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, gesturePoint);\n        }, onLayoutMeasure: function (measured) {\n            measuredLayout.current = measured;\n        }, ref: externalRef }), children));\n}\nvar Item = React.forwardRef(ReorderItem);\n\nvar Reorder = {\n    Group: Group,\n    Item: Item,\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(tslib.__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\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\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    }, [JSON.stringify(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\nvar createScrollMotionValues = function () { return ({\n    scrollX: motionValue(0),\n    scrollY: motionValue(0),\n    scrollXProgress: motionValue(0),\n    scrollYProgress: motionValue(0),\n}); };\nfunction useScroll(_a) {\n    if (_a === void 0) { _a = {}; }\n    var container = _a.container, target = _a.target, options = tslib.__rest(_a, [\"container\", \"target\"]);\n    var values = useConstant(createScrollMotionValues);\n    useIsomorphicLayoutEffect(function () {\n        return dom.scroll(function (_a) {\n            var x = _a.x, y = _a.y;\n            values.scrollX.set(x.current);\n            values.scrollXProgress.set(x.progress);\n            values.scrollY.set(y.current);\n            values.scrollYProgress.set(y.progress);\n        }, tslib.__assign(tslib.__assign({}, options), { container: (container === null || container === void 0 ? void 0 : container.current) || undefined, target: (target === null || target === void 0 ? void 0 : target.current) || undefined }));\n    }, []);\n    return values;\n}\n\nfunction useElementScroll(ref) {\n    warnOnce(false, \"useElementScroll is deprecated. Convert to useScroll({ container: ref }).\");\n    return useScroll({ container: ref });\n}\n\nfunction useViewportScroll() {\n    warnOnce(false, \"useViewportScroll is deprecated. Convert to useScroll().\");\n    return useScroll();\n}\n\nvar getCurrentTime = typeof performance !== \"undefined\"\n    ? function () { return performance.now(); }\n    : function () { return Date.now(); };\nfunction useAnimationFrame(callback) {\n    var initialTimestamp = useConstant(getCurrentTime);\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    React.useEffect(function () {\n        if (isStatic)\n            return;\n        var provideTimeSinceStart = function (_a) {\n            var timestamp = _a.timestamp;\n            callback(timestamp - initialTimestamp);\n        };\n        sync__default[\"default\"].update(provideTimeSinceStart, true);\n        return function () { return sync.cancelSync.update(provideTimeSinceStart); };\n    }, [callback]);\n}\n\nfunction useTime() {\n    var time = useMotionValue(0);\n    useAnimationFrame(function (t) { return time.set(t); });\n    return time;\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), false)).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 * ```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 useAnimationControls() {\n    var controls = useConstant(animationControls);\n    React.useEffect(controls.mount, []);\n    return controls;\n}\nvar useAnimation = useAnimationControls;\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 * 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    var runCycle = React.useCallback(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    }, tslib.__spreadArray([items.length], tslib.__read(items), false));\n    return [item, runCycle];\n}\n\nfunction useInView(ref, _a) {\n    var _b = _a === void 0 ? {} : _a, root = _b.root, margin = _b.margin, amount = _b.amount, _c = _b.once, once = _c === void 0 ? false : _c;\n    var _d = tslib.__read(React.useState(false), 2), isInView = _d[0], setInView = _d[1];\n    React.useEffect(function () {\n        var _a;\n        if (!ref.current || (once && isInView))\n            return;\n        var onEnter = function () {\n            setInView(true);\n            return once ? undefined : function () { return setInView(false); };\n        };\n        var options = {\n            root: (_a = root === null || root === void 0 ? void 0 : root.current) !== null && _a !== void 0 ? _a : undefined,\n            margin: margin,\n            amount: amount === \"some\" ? \"any\" : amount,\n        };\n        return dom.inView(ref.current, onEnter, options);\n    }, [root, ref, margin, once]);\n    return isInView;\n}\n\n/**\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\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    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 * ```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\nfunction useInstantLayoutTransition() {\n    return startTransition;\n}\nfunction startTransition(cb) {\n    if (!rootProjectionNode.current)\n        return;\n    rootProjectionNode.current.isUpdating = false;\n    rootProjectionNode.current.blockUpdate();\n    cb === null || cb === void 0 ? void 0 : cb();\n}\n\nfunction useInstantTransition() {\n    var _a = tslib.__read(useForceUpdate(), 2), forceUpdate = _a[0], forcedRenderCount = _a[1];\n    var startInstantLayoutTransition = useInstantLayoutTransition();\n    React.useEffect(function () {\n        /**\n         * Unblock after two animation frames, otherwise this will unblock too soon.\n         */\n        sync__default[\"default\"].postRender(function () {\n            return sync__default[\"default\"].postRender(function () { return (instantAnimationState.current = false); });\n        });\n    }, [forcedRenderCount]);\n    return function (callback) {\n        startInstantLayoutTransition(function () {\n            instantAnimationState.current = true;\n            forceUpdate();\n            callback();\n        });\n    };\n}\n\nfunction useResetProjection() {\n    var reset = React__namespace.useCallback(function () {\n        var root = rootProjectionNode.current;\n        if (!root)\n            return;\n        root.resetTree();\n    }, []);\n    return reset;\n}\n\nvar createObject = function () { return ({}); };\nvar stateVisualElement = visualElement({\n    build: function () { },\n    measureViewportBox: createBox,\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 */\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    }, [element]);\n    React.useEffect(function () {\n        element.setProps({\n            onUpdate: function (v) {\n                setAnimationState(tslib.__assign({}, v));\n            },\n        });\n    }, [setAnimationState, element]);\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 * ```jsx\n * const MyComponent = () => {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <motion.div style={{ scaleX, scaleY }} />\n * }\n * ```\n *\n * @deprecated\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.DeprecatedLayoutGroupContext = DeprecatedLayoutGroupContext;\nexports.DragControls = DragControls;\nexports.FlatTree = FlatTree;\nexports.LayoutGroup = LayoutGroup;\nexports.LayoutGroupContext = LayoutGroupContext;\nexports.LazyMotion = LazyMotion;\nexports.MotionConfig = MotionConfig;\nexports.MotionConfigContext = MotionConfigContext;\nexports.MotionContext = MotionContext;\nexports.MotionValue = MotionValue;\nexports.PresenceContext = PresenceContext;\nexports.Reorder = Reorder;\nexports.SwitchLayoutGroupContext = SwitchLayoutGroupContext;\nexports.addPointerEvent = addPointerEvent;\nexports.addScaleCorrector = addScaleCorrector;\nexports.animate = animate;\nexports.animateVisualElement = animateVisualElement;\nexports.animationControls = animationControls;\nexports.animations = animations;\nexports.calcLength = calcLength;\nexports.checkTargetForNewValues = checkTargetForNewValues;\nexports.createBox = createBox;\nexports.createDomMotionComponent = createDomMotionComponent;\nexports.createMotionComponent = createMotionComponent;\nexports.domAnimation = domAnimation;\nexports.domMax = domMax;\nexports.filterProps = filterProps;\nexports.isBrowser = isBrowser;\nexports.isDragActive = isDragActive;\nexports.isMotionValue = isMotionValue;\nexports.isValidMotionProp = isValidMotionProp;\nexports.m = m;\nexports.makeUseVisualState = makeUseVisualState;\nexports.motion = motion;\nexports.motionValue = motionValue;\nexports.resolveMotionValue = resolveMotionValue;\nexports.transform = transform;\nexports.useAnimation = useAnimation;\nexports.useAnimationControls = useAnimationControls;\nexports.useAnimationFrame = useAnimationFrame;\nexports.useCycle = useCycle;\nexports.useDeprecatedAnimatedState = useAnimatedState;\nexports.useDeprecatedInvertedScale = useInvertedScale;\nexports.useDomEvent = useDomEvent;\nexports.useDragControls = useDragControls;\nexports.useElementScroll = useElementScroll;\nexports.useForceUpdate = useForceUpdate;\nexports.useInView = useInView;\nexports.useInstantLayoutTransition = useInstantLayoutTransition;\nexports.useInstantTransition = useInstantTransition;\nexports.useIsPresent = useIsPresent;\nexports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;\nexports.useMotionTemplate = useMotionTemplate;\nexports.useMotionValue = useMotionValue;\nexports.usePresence = usePresence;\nexports.useReducedMotion = useReducedMotion;\nexports.useReducedMotionConfig = useReducedMotionConfig;\nexports.useResetProjection = useResetProjection;\nexports.useScroll = useScroll;\nexports.useSpring = useSpring;\nexports.useTime = useTime;\nexports.useTransform = useTransform;\nexports.useUnmountEffect = useUnmountEffect;\nexports.useVelocity = useVelocity;\nexports.useViewportScroll = useViewportScroll;\nexports.useVisualElementContext = useVisualElementContext;\nexports.visualElement = visualElement;\nexports.wrapHandler = wrapHandler;\n"],"names":["Object","defineProperty","exports","value","tslib","React","heyListen","styleValueTypes","popmotion","sync","dom","_interopDefaultLegacy","e","_interopNamespace","__esModule","n","create","keys","forEach","k","d","getOwnPropertyDescriptor","get","enumerable","freeze","React__namespace","React__default","sync__default","env","createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","inView","loadFeatures","features","key","projectionNodeConstructor","Component","LazyContext","createContext","strict","featureNames","numFeatures","length","MotionConfigContext","transformPagePoint","p","isStatic","reducedMotion","MotionContext","useVisualElementContext","useContext","visualElement","PresenceContext","isBrowser","document","useIsomorphicLayoutEffect","useLayoutEffect","useEffect","prefersReducedMotion","current","hasDetected","useReducedMotion","window","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","__read","useState","useReducedMotionConfig","reducedMotionPreference","isRefObject","ref","prototype","hasOwnProperty","call","isVariantLabels","v","Array","isArray","isVariantLabel","resolveVariantFromProps","definition","custom","currentValues","currentVelocity","_a","variants","resolveVariant","getProps","forEachValue","getCurrent","velocity","getVelocity","getVelocity$1","checkIfControllingVariants","animate","start","initial","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","Boolean","useCreateMotionContext","context","undefined","inherit","getCurrentTreeVariants","useMemo","variantLabelsAsDependency","prop","join","useConstant","init","useRef","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","id$1","LayoutGroupContext","SwitchLayoutGroupContext","VisualElementHandler","_super","apply","this","arguments","__extends","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","setProps","render","children","createMotionComponent","preloadedFeatures","createVisualElement","useRender","useVisualState","forwardRef","externalRef","layoutId","_b","layoutGroupId","id","useLayoutId","__assign","config","projectionId","visualState","lazyContext","parent","presenceContext","shouldReduceMotion","visualElementRef","renderer","presenceId","blockInitialAnimation","syncRender","animationState","animateChanges","notifyUnmount","useVisualElement","ProjectionNodeConstructor","layout","dragConstraints","layoutScroll","initialPromotionConfig","projection","getLatestValues","setOptions","alwaysMeasureLayout","scheduleRender","animationType","useProjection","invariant","i","name_1","push","createElement","useFeatures","Provider","useCallback","instance","mount","unmount","useMotionRef","createMotionProxy","createConfig","customMotionComponentConfig","Proxy","componentCache","Map","_target","has","set","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","scaleCorrectors","addScaleCorrector","correctors","assign","transformAxes","transformProps","sortTransformProps","a","b","operationKey","axesKey","transformPropSet","Set","isTransformProp","transformOriginProps","isTransformOriginProp","isForcedMotionValue","isMotionValue","translateAlias","x","y","z","transformPerspective","isCSSVariable$1","startsWith","getValueAsType","type","transform","int","number","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","options","transformTemplate","style","vars","transformKeys","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","default","transformIsDefault","_c","enableHardwareAcceleration","_d","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","concat","trim","buildTransform","buildTransformOrigin","createHtmlRenderState","copyRawValuesOnly","target","source","useStyle","useInitialMotionValues","transformValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","validMotionProps","isValidMotionProp","shouldForward","loadExternalIsValidProp","isValidProp","filterProps","isDom","forwardMotionProps","filteredProps","calcOrigin$1","origin","offset","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","__rest","attrs","dimensions","pxOriginX","pxOriginY","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","createSvgRenderState","useSVGProps","visualProps","rawStyles","createUseRender","elementProps","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","renderHTML","element","styleProp","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps$1","newValues","scrapeMotionValuesFromProps","toUpperCase","isAnimationControls","isKeyframesTarget","isCustomValue","mix","toValue","resolveFinalValueInKeyframes","resolveMotionValue","unwrappedValue","makeState","createRenderState","onMount","makeLatestValues","makeUseVisualState","scrapeMotionValues","values","motionValues","isControllingVariants","isVariantNode","initialAnimationIsBlocked","variantToSet","resolved","transitionEnd","transition","valueTarget","AnimationType","svgMotionConfig","getBBox","getBoundingClientRect","htmlMotionConfig","createDomMotionConfig","baseConfig","addDomEvent","eventName","handler","passive","addEventListener","removeEventListener","useDomEvent","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","point","changedTouches","pointFromMouse","extractEventInfo","wrapHandler","shouldFilterPrimaryPointer","eventHandler","listener","button","supportsPointerEvents","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","createHoverEvent","isActive","callback","info","setActive","Hover","isNodeOrChild","child","parentElement","useUnmountEffect","warned","warnOnce","condition","message","console","warn","add","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","root","lookupRoot","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","delete","unobserve","thresholdNames","all","useIntersectionObserver","shouldObserve","rootMargin","amount","once","threshold","getInstance","isIntersecting","isInView","hasEnteredView","InView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","fallback","requestAnimationFrame","makeRenderlessComponent","hook","gestureAnimations","whileInView","viewport","onTap","onTapStart","onTapCancel","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","Tap","onPointerUp","onPointerCancel","pipe","Focus","onHoverStart","onHoverEnd","counter","incrementId","useId","usePresence","isPresent","onExitComplete","register","shallowCompare","next","prev","prevLength","secondsToMilliseconds","seconds","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","x1","y1","x2","y2","cubicBezier","isEasingArray","ease","isAnimatable","complex","underDampedSpring","stiffness","damping","restSpeed","criticallyDampedSpring","to","sqrt","linearTween","duration","keyframes","defaultTransitions","backgroundColor","color","getDefaultTransition","valueKey","transitionFactory","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","filter","WebkitFilter","getDefaultValueType","getAnimatableNone","defaultValueType","instantAnimationState","legacyRepeatWarning","getPopmotionAnimationOptions","__spreadArray","from","hydrateKeyframes","when","delay","delayChildren","staggerChildren","staggerDirection","repeat","repeatType","repeatDelay","isTransitionDefined","times","yoyo","flip","loop","map","warning","convertTransitionToAnimationOptions","isZero","parseFloat","getZeroUnit","potentialUnitType","getValueTransition","startAnimation","onComplete","delayTimer","controls","valueTransition","isTargetAnimatable","isOriginAnimatable","onUpdate","inertia","finalTarget","stop","getAnimation","getDelayFromTransition","setTimeout","clearTimeout","isZeroValueString","addUniqueItem","arr","item","removeItem","index","splice","SubscriptionManager","subscriptions","_this","notify","c","numSubscriptions","getSize","clear","MotionValue","version","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","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","findValueType","setMotionValue","hasValue","getValue","addValue","setTarget","makeTargetAnimatable","setVariants","variantLabels","reverse","variant","getVariant","variantChildren","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","getOrigin","animateVisualElement","notifyAnimationStart","animations","animateVariant","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getChildAnimations","forwardDelay","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","animateChildren","first","last","_e","_f","animationTypeState","getState","shouldBlockAnimation","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","variantPriorityOrder","Animate","Drag","Exit","reversePriorityOrder","numAnimationTypes","createAnimationState","animateList","createTypeState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","isAnimated","setAnimateFunction","makeAnimator","subscribe","safeToRemove","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","calcLength","axis","max","min","isNear","maxDistance","calcAxisDelta","originPoint","translate","calcBoxDelta","calcRelativeAxis","relative","calcRelativeAxisPosition","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","convertBoundingBoxToBox","isIdentityScale","hasScale","hasTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","translateAxis","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys$1","yKeys$1","transformBox","measureViewportBox","topLeft","bottomRight","transformBoxPoints","elementDragControls","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","panSession","dragPropagation","onDragStart","resolveConstraints","isAnimationBlocked","getAxisMotionValue","measuredAxis","actual","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","abs","getCurrentDirection","updateAxis","getTransformPagePoint","cancel","onDragEnd","_point","shouldDrag","axisValue","prevConstraints","resolveRefConstraints","layoutBox","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","bounceStiffness","bounceDamping","timeConstant","restDelta","startAxisValueAnimation","dragKey","externalMotionValue","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","latest","progress","clamp","updateScroll","updateLayout","addListeners","stopPointerListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","groupDragControls","dragControls","names","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","removeFromVariantTree","isMounted","lifecycles","managers","propSubscriptions","clearAllListeners","manager","updatePropListeners","on","propListener","args","_i","createLifecycles","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","notifyUpdate","bindToMotionValue","removeOnChange","latestValue","removeOnRenderRequest","initialMotionValues","depth","isVisible","newInstance","addVariantChild","remove","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","setVisibility","visibility","canMutate","removeValue","defaultValue","newProps","nextValue","prevValue","existingValue","updateMotionValuesFromProps","startAtParent","context_1","numVariantProps","variantProps","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","match","exec","parseCSSVariable","token","getComputedStyle","getPropertyValue","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","positionalValues","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY_1","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","targetBbox","convertChangedValueTypes","scrollTo","unitConversion","hasPositionalKey","parseDomVariant","Element","resolveCSSVariables","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","parsed","htmlVisualElement","svgVisualElement","getAttribute","_element","createDomVisualElement","pixelsToPercent","pixels","correctBorderRadius","correct","node","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","cssVariables","shadow","template","createTransformer","xScale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","componentDidMount","layoutGroup","switchLayoutGroup","defaultScaleCorrectors","group","didUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","deregister","applyTo","boxShadow","layoutFeatures","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","easing","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","identityProjection","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","isDirty","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","ProjectionNode","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","animationProgress","sharedNodes","path","registerPotentialNode","notifyListeners","subscriptionManager","hasListeners","SVGElement","tagName","unblockTimeout_1","resizeUnblockUpdate_1","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","mountNodeEarly","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","measure","removeTransform","removeElementScroll","roundBox","prevLayout","layoutCorrected","notifyLayoutMeasure","isScrollRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","attemptToResolveRelativeTarget","pendingAnimation","getLead","treePath","isSharedTransition","treeLength","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","completeAnimation","applyTransformsToTarget","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","styles","pointerEvents","emptyStyles","valuesToRender","_h","corrected","num","resetTree","layout_1","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","searchNode","querySelector","roundAxis","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","documentNode","position","featureBundle","motion","m","useIsMounted","useForceUpdate","forcedRenderCount","setForcedRenderCount","forceRender","PresenceChild","presenceAffectsLayout","presenceChildren","newChildrenMap","childId","e_1","__values","done","e_1_1","error","return","_","getChildKey","DeprecatedLayoutGroupContext","nodeGroup","dirtyAll","dirty","shouldInheritGroup","LayoutGroup","inheritId","layoutGroupContext","deprecatedLayoutGroupContext","upstreamId","shouldInheritId","memoizedContext","isLazyBundle","ReorderContext","checkReorder","order","nextOffset","nextItem","nextLayout","nextItemCenter","toIndex","slice","startIndex","endIndex","moveItem","Group","as","onReorder","isReordering","registerItem","compareMin","updateOrder","newOrder","useMotionValue","setLatest_1","getMixer","isCustomValueType","useImmediate","argOffset","inputValue","inputRange","outputRange","interpolator","interpolate","mixer","useCombineMotionValues","combineValues","updateValue","unsubscribe","useMultiOnChange","useTransform","input","inputRangeOrTransformer","transformer","useListTransform","numValues","useDefaultMotionValue","Reorder","Item","latestX","latestY","gesturePoint","onLayoutMeasure","domAnimation","domMax","createScrollMotionValues","scrollX","scrollY","scrollXProgress","scrollYProgress","useScroll","container","getCurrentTime","performance","now","Date","useAnimationFrame","initialTimestamp","provideTimeSinceStart","animationControls","hasMounted","pendingAnimations","subscribers","animations_1","setValues","useAnimationControls","useAnimation","DragControls","componentControls","nativeEvent","createDragControls","useInstantLayoutTransition","startTransition","cb","createObject","stateVisualElement","_state","initialState","invertScale","hasWarned","AnimatePresence","exitBeforeEnter","forceRenderLayoutGroup","filteredChildren","filtered","Children","isValidElement","onlyElements","childrenToRender","exiting","presentChildren","allChildren","updateChildLookup","Fragment","presentKeys","targetKeys","numPresent","insertionIndex","removeIndex","presentChild","cloneElement","AnimateSharedLayout","LazyMotion","setIsLoaded","loadedRenderer","loadedFeatures","MotionConfig","createDomMotionComponent","useCycle","items","setItem","wrap","useDeprecatedAnimatedState","setAnimationState","animationDefinition","useDeprecatedInvertedScale","parentScaleX","parentScaleY","useDragControls","useElementScroll","useInView","setInView","useInstantTransition","forceUpdate","startInstantLayoutTransition","useIsPresent","useMotionTemplate","fragments","numFragments","useResetProjection","useSpring","activeSpringAnimation","useOnChange","useTime","t","useVelocity","newVelocity","useViewportScroll"],"sourceRoot":""}