{"version":3,"file":"javascripts/87806.2b03bcf22fb2513b8b4e.js","mappings":"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","sources":["webpack:///../../node_modules/framer-motion/dist/cjs/index.js"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar React = require('react');\nvar indexLegacy = require('./index-legacy-87714a68.js');\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);\n\n/**\n * @public\n */\nconst MotionConfigContext = React.createContext({\n    transformPagePoint: (p) => p,\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nconst MotionContext = React.createContext({});\n\n/**\n * @public\n */\nconst PresenceContext = React.createContext(null);\n\nconst useIsomorphicLayoutEffect = indexLegacy.isBrowser ? React.useLayoutEffect : React.useEffect;\n\nconst LazyContext = React.createContext({ strict: false });\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    const { visualElement: parent } = React.useContext(MotionContext);\n    const lazyContext = React.useContext(LazyContext);\n    const presenceContext = React.useContext(PresenceContext);\n    const reducedMotionConfig = React.useContext(MotionConfigContext).reducedMotion;\n    const visualElementRef = React.useRef();\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    createVisualElement = createVisualElement || lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState,\n            parent,\n            props,\n            presenceContext,\n            blockInitialAnimation: presenceContext\n                ? presenceContext.initial === false\n                : false,\n            reducedMotionConfig,\n        });\n    }\n    const visualElement = visualElementRef.current;\n    React.useInsertionEffect(() => {\n        visualElement && visualElement.update(props, presenceContext);\n    });\n    /**\n     * Cache this value as we want to know whether HandoffAppearAnimations\n     * was present on initial render - it will be deleted after this.\n     */\n    const wantsHandoff = React.useRef(Boolean(props[indexLegacy.optimizedAppearDataAttribute] && !window.HandoffComplete));\n    useIsomorphicLayoutEffect(() => {\n        if (!visualElement)\n            return;\n        visualElement.render();\n        /**\n         * Ideally this function would always run in a useEffect.\n         *\n         * However, if we have optimised appear animations to handoff from,\n         * it needs to happen synchronously to ensure there's no flash of\n         * incorrect styles in the event of a hydration error.\n         *\n         * So if we detect a situtation where optimised appear animations\n         * are running, we use useLayoutEffect to trigger animations.\n         */\n        if (wantsHandoff.current && visualElement.animationState) {\n            visualElement.animationState.animateChanges();\n        }\n    });\n    React.useEffect(() => {\n        if (!visualElement)\n            return;\n        visualElement.updateFeatures();\n        if (!wantsHandoff.current && visualElement.animationState) {\n            visualElement.animationState.animateChanges();\n        }\n        if (wantsHandoff.current) {\n            wantsHandoff.current = false;\n            // This ensures all future calls to animateChanges() will run in useEffect\n            window.HandoffComplete = true;\n        }\n    });\n    return visualElement;\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((instance) => {\n        instance && visualState.mount && visualState.mount(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 (indexLegacy.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\nfunction getCurrentTreeVariants(props, context) {\n    if (indexLegacy.isControllingVariants(props)) {\n        const { initial, animate } = props;\n        return {\n            initial: initial === false || indexLegacy.isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: indexLegacy.isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nfunction useCreateMotionContext(props) {\n    const { initial, animate } = getCurrentTreeVariants(props, React.useContext(MotionContext));\n    return React.useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nfunction loadFeatures(features) {\n    for (const key in features) {\n        indexLegacy.featureDefinitions[key] = {\n            ...indexLegacy.featureDefinitions[key],\n            ...features[key],\n        };\n    }\n}\n\nconst LayoutGroupContext = React.createContext({});\n\n/**\n * Internal, exported only for usage in Framer\n */\nconst SwitchLayoutGroupContext = React.createContext({});\n\nconst motionComponentSymbol = Symbol.for(\"motionComponentSymbol\");\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({ preloadedFeatures, createVisualElement, useRender, useVisualState, Component, }) {\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        /**\n         * If we need to measure the element we load this functionality in a\n         * separate class component in order to gain access to getSnapshotBeforeUpdate.\n         */\n        let MeasureLayout;\n        const configAndProps = {\n            ...React.useContext(MotionConfigContext),\n            ...props,\n            layoutId: useLayoutId(props),\n        };\n        const { isStatic } = configAndProps;\n        const context = useCreateMotionContext(props);\n        const visualState = useVisualState(props, isStatic);\n        if (!isStatic && indexLegacy.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, configAndProps, createVisualElement);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            const initialLayoutGroupConfig = React.useContext(SwitchLayoutGroupContext);\n            const isStrict = React.useContext(LazyContext).strict;\n            if (context.visualElement) {\n                MeasureLayout = context.visualElement.loadFeatures(\n                // Note: Pass the full new combined props to correctly re-render dynamic feature components.\n                configAndProps, isStrict, preloadedFeatures, initialLayoutGroupConfig);\n            }\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(MotionContext.Provider, { value: context },\n            MeasureLayout && context.visualElement ? (React__namespace.createElement(MeasureLayout, { visualElement: context.visualElement, ...configAndProps })) : null,\n            useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)));\n    }\n    const ForwardRefComponent = React.forwardRef(MotionComponent);\n    ForwardRefComponent[motionComponentSymbol] = Component;\n    return ForwardRefComponent;\n}\nfunction useLayoutId({ layoutId }) {\n    const layoutGroupId = React.useContext(LayoutGroupContext).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        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    const componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: (_target, key) => {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\n/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nconst lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"switch\",\n    \"symbol\",\n    \"svg\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\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\nconst createHtmlRenderState = () => ({\n    style: {},\n    transform: {},\n    transformOrigin: {},\n    vars: {},\n});\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (const key in source) {\n        if (!indexLegacy.isMotionValue(source[key]) && !indexLegacy.isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues({ transformTemplate }, visualState, isStatic) {\n    return React.useMemo(() => {\n        const state = createHtmlRenderState();\n        indexLegacy.buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        return Object.assign({}, state.vars, state.style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    const styleProp = props.style || {};\n    const style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    return props.transformValues ? props.transformValues(style) : style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    const htmlProps = {};\n    const style = useStyle(props, visualState, isStatic);\n    if (props.drag && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : `pan-${props.drag === \"x\" ? \"y\" : \"x\"}`;\n    }\n    if (props.tabIndex === undefined &&\n        (props.onTap || props.onTapStart || props.whileTap)) {\n        htmlProps.tabIndex = 0;\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\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 */\nconst validMotionProps = new Set([\n    \"animate\",\n    \"exit\",\n    \"variants\",\n    \"initial\",\n    \"style\",\n    \"values\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"_dragX\",\n    \"_dragY\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"globalTapTarget\",\n    \"ignoreStrict\",\n    \"viewport\",\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 (key.startsWith(\"while\") ||\n        (key.startsWith(\"drag\") && key !== \"draggable\") ||\n        key.startsWith(\"layout\") ||\n        key.startsWith(\"onTap\") ||\n        key.startsWith(\"onPan\") ||\n        key.startsWith(\"onLayout\") ||\n        validMotionProps.has(key));\n}\n\nlet shouldForward = (key) => !isValidMotionProp(key);\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = (key) => key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    const filteredProps = {};\n    for (const key in props) {\n        /**\n         * values is considered a valid prop by Emotion, so if it's present\n         * this will be rendered out to the DOM unless explicitly filtered.\n         *\n         * We check the type as it could be used with the `feColorMatrix`\n         * element, which we support.\n         */\n        if (key === \"values\" && typeof props.values === \"object\")\n            continue;\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nconst createSvgRenderState = () => ({\n    ...createHtmlRenderState(),\n    attrs: {},\n});\n\nfunction useSVGProps(props, visualState, _isStatic, Component) {\n    const visualProps = React.useMemo(() => {\n        const state = createSvgRenderState();\n        indexLegacy.buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, indexLegacy.isSVGTag(Component), props.transformTemplate);\n        return {\n            ...state.attrs,\n            style: { ...state.style },\n        };\n    }, [visualState]);\n    if (props.style) {\n        const rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = { ...rawStyles, ...visualProps.style };\n    }\n    return visualProps;\n}\n\nfunction createUseRender(forwardMotionProps = false) {\n    const useRender = (Component, props, ref, { latestValues }, isStatic) => {\n        const useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        const visualProps = useVisualProps(props, latestValues, isStatic, Component);\n        const filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        const elementProps = {\n            ...filteredProps,\n            ...visualProps,\n            ref,\n        };\n        /**\n         * If component has been handed a motion value as its child,\n         * memoise its initial value and render that. Subsequent updates\n         * will be handled by the onChange handler\n         */\n        const { children } = props;\n        const renderedChildren = React.useMemo(() => (indexLegacy.isMotionValue(children) ? children.get() : children), [children]);\n        return React.createElement(Component, {\n            ...elementProps,\n            children: renderedChildren,\n        });\n    };\n    return useRender;\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    const ref = React.useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\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    const unwrappedValue = indexLegacy.isMotionValue(value) ? value.get() : value;\n    return indexLegacy.isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nfunction makeState({ scrapeMotionValuesFromProps, createRenderState, onMount, }, props, context, presenceContext) {\n    const state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = (instance) => onMount(props, instance, state);\n    }\n    return state;\n}\nconst makeUseVisualState = (config) => (props, isStatic) => {\n    const context = React.useContext(MotionContext);\n    const presenceContext = React.useContext(PresenceContext);\n    const make = () => makeState(config, props, context, presenceContext);\n    return isStatic ? make() : useConstant(make);\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    const values = {};\n    const motionValues = scrapeMotionValues(props, {});\n    for (const key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    let { initial, animate } = props;\n    const isControllingVariants = indexLegacy.isControllingVariants(props);\n    const isVariantNode = indexLegacy.isVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        if (initial === undefined)\n            initial = context.initial;\n        if (animate === undefined)\n            animate = context.animate;\n    }\n    let isInitialAnimationBlocked = presenceContext\n        ? presenceContext.initial === false\n        : false;\n    isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;\n    const variantToSet = isInitialAnimationBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !indexLegacy.isAnimationControls(variantToSet)) {\n        const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach((definition) => {\n            const resolved = indexLegacy.resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            const { transitionEnd, transition, ...target } = resolved;\n            for (const key in target) {\n                let 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                    const index = isInitialAnimationBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (const key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nconst svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: indexLegacy.scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: (props, instance, { renderState, latestValues }) => {\n            indexLegacy.frame.read(() => {\n                try {\n                    renderState.dimensions =\n                        typeof instance.getBBox ===\n                            \"function\"\n                            ? instance.getBBox()\n                            : instance.getBoundingClientRect();\n                }\n                catch (e) {\n                    // Most likely trying to measure an unrendered element under Firefox\n                    renderState.dimensions = {\n                        x: 0,\n                        y: 0,\n                        width: 0,\n                        height: 0,\n                    };\n                }\n            });\n            indexLegacy.frame.render(() => {\n                indexLegacy.buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, indexLegacy.isSVGTag(instance.tagName), props.transformTemplate);\n                indexLegacy.renderSVG(instance, renderState);\n            });\n        },\n    }),\n};\n\nconst htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: indexLegacy.scrapeMotionValuesFromProps$1,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nfunction createDomMotionConfig(Component, { forwardMotionProps = false }, preloadedFeatures, createVisualElement) {\n    const baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return {\n        ...baseConfig,\n        preloadedFeatures,\n        useRender: createUseRender(forwardMotionProps),\n        createVisualElement,\n        Component,\n    };\n}\n\nfunction addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nconst isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: {\n            x: event[pointType + \"X\"],\n            y: event[pointType + \"Y\"],\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, eventName, addPointerInfo(handler), options);\n}\n\nfunction createLock(name) {\n    let lock = null;\n    return () => {\n        const openLock = () => {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nconst globalHorizontalLock = createLock(\"dragHorizontal\");\nconst globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    let lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        const openHorizontal = globalHorizontalLock();\n        const openVertical = globalVerticalLock();\n        if (openHorizontal && openVertical) {\n            lock = () => {\n                openHorizontal();\n                openVertical();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal)\n                openHorizontal();\n            if (openVertical)\n                openVertical();\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    const openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nclass Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nfunction addHoverEvent(node, isActive) {\n    const eventName = \"pointer\" + (isActive ? \"enter\" : \"leave\");\n    const callbackName = \"onHover\" + (isActive ? \"Start\" : \"End\");\n    const handleEvent = (event, info) => {\n        if (event.pointerType === \"touch\" || isDragActive())\n            return;\n        const props = node.getProps();\n        if (node.animationState && props.whileHover) {\n            node.animationState.setActive(\"whileHover\", isActive);\n        }\n        if (props[callbackName]) {\n            indexLegacy.frame.update(() => props[callbackName](event, info));\n        }\n    };\n    return addPointerEvent(node.current, eventName, handleEvent, {\n        passive: !node.getProps()[callbackName],\n    });\n}\nclass HoverGesture extends Feature {\n    mount() {\n        this.unmount = indexLegacy.pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));\n    }\n    unmount() { }\n}\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = indexLegacy.pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\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 */\nconst isNodeOrChild = (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 fireSyntheticPointerEvent(name, handler) {\n    if (!handler)\n        return;\n    const syntheticPointerEvent = new PointerEvent(\"pointer\" + name);\n    handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));\n}\nclass PressGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removeStartListeners = indexLegacy.noop;\n        this.removeEndListeners = indexLegacy.noop;\n        this.removeAccessibleListeners = indexLegacy.noop;\n        this.startPointerPress = (startEvent, startInfo) => {\n            if (this.isPressing)\n                return;\n            this.removeEndListeners();\n            const props = this.node.getProps();\n            const endPointerPress = (endEvent, endInfo) => {\n                if (!this.checkPressEnd())\n                    return;\n                const { onTap, onTapCancel, globalTapTarget } = this.node.getProps();\n                indexLegacy.frame.update(() => {\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                    !globalTapTarget &&\n                        !isNodeOrChild(this.node.current, endEvent.target)\n                        ? onTapCancel && onTapCancel(endEvent, endInfo)\n                        : onTap && onTap(endEvent, endInfo);\n                });\n            };\n            const removePointerUpListener = addPointerEvent(window, \"pointerup\", endPointerPress, { passive: !(props.onTap || props[\"onPointerUp\"]) });\n            const removePointerCancelListener = addPointerEvent(window, \"pointercancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), { passive: !(props.onTapCancel || props[\"onPointerCancel\"]) });\n            this.removeEndListeners = indexLegacy.pipe(removePointerUpListener, removePointerCancelListener);\n            this.startPress(startEvent, startInfo);\n        };\n        this.startAccessiblePress = () => {\n            const handleKeydown = (keydownEvent) => {\n                if (keydownEvent.key !== \"Enter\" || this.isPressing)\n                    return;\n                const handleKeyup = (keyupEvent) => {\n                    if (keyupEvent.key !== \"Enter\" || !this.checkPressEnd())\n                        return;\n                    fireSyntheticPointerEvent(\"up\", (event, info) => {\n                        const { onTap } = this.node.getProps();\n                        if (onTap) {\n                            indexLegacy.frame.update(() => onTap(event, info));\n                        }\n                    });\n                };\n                this.removeEndListeners();\n                this.removeEndListeners = addDomEvent(this.node.current, \"keyup\", handleKeyup);\n                fireSyntheticPointerEvent(\"down\", (event, info) => {\n                    this.startPress(event, info);\n                });\n            };\n            const removeKeydownListener = addDomEvent(this.node.current, \"keydown\", handleKeydown);\n            const handleBlur = () => {\n                if (!this.isPressing)\n                    return;\n                fireSyntheticPointerEvent(\"cancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));\n            };\n            const removeBlurListener = addDomEvent(this.node.current, \"blur\", handleBlur);\n            this.removeAccessibleListeners = indexLegacy.pipe(removeKeydownListener, removeBlurListener);\n        };\n    }\n    startPress(event, info) {\n        this.isPressing = true;\n        const { onTapStart, whileTap } = this.node.getProps();\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", true);\n        }\n        if (onTapStart) {\n            indexLegacy.frame.update(() => onTapStart(event, info));\n        }\n    }\n    checkPressEnd() {\n        this.removeEndListeners();\n        this.isPressing = false;\n        const props = this.node.getProps();\n        if (props.whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", false);\n        }\n        return !isDragActive();\n    }\n    cancelPress(event, info) {\n        if (!this.checkPressEnd())\n            return;\n        const { onTapCancel } = this.node.getProps();\n        if (onTapCancel) {\n            indexLegacy.frame.update(() => onTapCancel(event, info));\n        }\n    }\n    mount() {\n        const props = this.node.getProps();\n        const removePointerListener = addPointerEvent(props.globalTapTarget ? window : this.node.current, \"pointerdown\", this.startPointerPress, { passive: !(props.onTapStart || props[\"onPointerStart\"]) });\n        const removeFocusListener = addDomEvent(this.node.current, \"focus\", this.startAccessiblePress);\n        this.removeStartListeners = indexLegacy.pipe(removePointerListener, removeFocusListener);\n    }\n    unmount() {\n        this.removeStartListeners();\n        this.removeEndListeners();\n        this.removeAccessibleListeners();\n    }\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 */\nconst 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 */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const 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    const rootObservers = observers.get(lookupRoot);\n    const 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, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    startObserver() {\n        this.unmount();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once } = viewport;\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.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 && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() { }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nfunction shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    const prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (let i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    const resolved = indexLegacy.resolveVariant(visualElement, variant, options.custom);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\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    const getAnimation = resolved\n        ? () => Promise.all(indexLegacy.animateTarget(visualElement, resolved, options))\n        : () => 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    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => 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    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? indexLegacy.resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(indexLegacy.animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => visualElement.notify(\"AnimationComplete\", definition));\n}\n\nconst reversePriorityOrder = [...indexLegacy.variantPriorityOrder].reverse();\nconst numAnimationTypes = indexLegacy.variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = indexLegacy.resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        const props = visualElement.getProps();\n        const context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const propIsVariant = indexLegacy.isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && 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 = { ...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                indexLegacy.isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            let handledRemovedValues = false;\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                let valueHasChanged = false;\n                if (indexLegacy.isKeyframesTarget(next) && indexLegacy.isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    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 = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             */\n            if (shouldAnimateType && (!isInherited || handledRemovedValues)) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, 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((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nclass AnimationFeature extends Feature {\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    constructor(node) {\n        super(node);\n        node.animationState || (node.animationState = createAnimationState(node));\n    }\n    updateAnimationControlsSubscription() {\n        const { animate } = this.node.getProps();\n        this.unmount();\n        if (indexLegacy.isAnimationControls(animate)) {\n            this.unmount = animate.subscribe(this.node);\n        }\n    }\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    mount() {\n        this.updateAnimationControlsSubscription();\n    }\n    update() {\n        const { animate } = this.node.getProps();\n        const { animate: prevAnimate } = this.node.prevProps || {};\n        if (animate !== prevAnimate) {\n            this.updateAnimationControlsSubscription();\n        }\n    }\n    unmount() { }\n}\n\nlet id$2 = 0;\nclass ExitAnimationFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.id = id$2++;\n    }\n    update() {\n        if (!this.node.presenceContext)\n            return;\n        const { isPresent, onExitComplete, custom } = this.node.presenceContext;\n        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};\n        if (!this.node.animationState || isPresent === prevIsPresent) {\n            return;\n        }\n        const exitAnimation = this.node.animationState.setActive(\"exit\", !isPresent, { custom: custom !== null && custom !== void 0 ? custom : this.node.getProps().custom });\n        if (onExitComplete && !isPresent) {\n            exitAnimation.then(() => onExitComplete(this.id));\n        }\n    }\n    mount() {\n        const { register } = this.node.presenceContext || {};\n        if (register) {\n            this.unmount = register(this.id);\n        }\n    }\n    unmount() { }\n}\n\nconst animations = {\n    animation: {\n        Feature: AnimationFeature,\n    },\n    exit: {\n        Feature: ExitAnimationFeature,\n    },\n};\n\n/**\n * @internal\n */\nclass PanSession {\n    constructor(event, handlers, { transformPagePoint, contextWindow, dragSnapToOrigin = false } = {}) {\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        /**\n         * @internal\n         */\n        this.contextWindow = window;\n        this.updatePoint = () => {\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const info = getPanInfo(this.lastMoveEventInfo, this.history);\n            const 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            const isDistancePastThreshold = indexLegacy.distance2D(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            const { point } = info;\n            const { timestamp } = indexLegacy.frameData;\n            this.history.push({ ...point, timestamp });\n            const { onStart, onMove } = this.handlers;\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 = (event, info) => {\n            this.lastMoveEvent = event;\n            this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);\n            // Throttle mouse move event to once per frame\n            indexLegacy.frame.update(this.updatePoint, true);\n        };\n        this.handlePointerUp = (event, info) => {\n            this.end();\n            const { onEnd, onSessionEnd, resumeAnimation } = this.handlers;\n            if (this.dragSnapToOrigin)\n                resumeAnimation && resumeAnimation();\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const panInfo = getPanInfo(event.type === \"pointercancel\"\n                ? this.lastMoveEventInfo\n                : 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 (!isPrimaryPointer(event))\n            return;\n        this.dragSnapToOrigin = dragSnapToOrigin;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        this.contextWindow = contextWindow || window;\n        const info = extractEventInfo(event);\n        const initialInfo = transformPoint(info, this.transformPagePoint);\n        const { point } = initialInfo;\n        const { timestamp } = indexLegacy.frameData;\n        this.history = [{ ...point, timestamp }];\n        const { onSessionStart } = handlers;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = indexLegacy.pipe(addPointerEvent(this.contextWindow, \"pointermove\", this.handlePointerMove), addPointerEvent(this.contextWindow, \"pointerup\", this.handlePointerUp), addPointerEvent(this.contextWindow, \"pointercancel\", this.handlePointerUp));\n    }\n    updateHandlers(handlers) {\n        this.handlers = handlers;\n    }\n    end() {\n        this.removeListeners && this.removeListeners();\n        indexLegacy.cancelFrame(this.updatePoint);\n    }\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({ point }, history) {\n    return {\n        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    let i = history.length - 1;\n    let timestampedPoint = null;\n    const lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            indexLegacy.secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    const time = indexLegacy.millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    const 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 = 0, maxDistance = 0.01) {\n    return Math.abs(value - target) <= maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin = 0.5) {\n    delta.origin = origin;\n    delta.originPoint = indexLegacy.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        indexLegacy.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 ? origin.originX : undefined);\n    calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : undefined);\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, { min, max }, elastic) {\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? indexLegacy.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 ? indexLegacy.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, { top, left, bottom, 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    let min = constraintsAxis.min - layoutAxis.min;\n    let 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        [min, max] = [max, min];\n    }\n    return { min, 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    let origin = 0.5;\n    const sourceLength = calcLength(source);\n    const targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = indexLegacy.progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = indexLegacy.progress(source.min, source.max - targetLength, target.min);\n    }\n    return indexLegacy.clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    const 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}\nconst defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(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    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : dragElastic[label] || 0;\n}\n\nfunction eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\n// Fixes https://github.com/framer/motion/issues/2270\nconst getContextWindow = ({ current }) => {\n    return current ? current.ownerDocument.defaultView : null;\n};\n\nconst elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: PointerEvent\nclass VisualElementDragControls {\n    constructor(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 = indexLegacy.createBox();\n        this.visualElement = visualElement;\n    }\n    start(originEvent, { snapToCursor = false } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.isPresent === false)\n            return;\n        const onSessionStart = (event) => {\n            const { dragSnapToOrigin } = this.getProps();\n            // Stop or pause any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            dragSnapToOrigin ? this.pauseAnimation() : this.stopAnimation();\n            if (snapToCursor) {\n                this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        const onStart = (event, info) => {\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\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((axis) => {\n                let current = this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (indexLegacy.percent.test(current)) {\n                    const { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            if (onDragStart) {\n                indexLegacy.frame.update(() => onDragStart(event, info), false, true);\n            }\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", true);\n        };\n        const onMove = (event, info) => {\n            // latestPointerEvent = event\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openGlobalLock)\n                return;\n            const { offset } = info;\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 && 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.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag && onDrag(event, info);\n        };\n        const onSessionEnd = (event, info) => this.stop(event, info);\n        const resumeAnimation = () => eachAxis((axis) => {\n            var _a;\n            return this.getAnimationState(axis) === \"paused\" &&\n                ((_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.play());\n        });\n        const { dragSnapToOrigin } = this.getProps();\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n            resumeAnimation,\n        }, {\n            transformPagePoint: this.visualElement.getTransformPagePoint(),\n            dragSnapToOrigin,\n            contextWindow: getContextWindow(this.visualElement),\n        });\n    }\n    stop(event, info) {\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        const { velocity } = info;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        if (onDragEnd) {\n            indexLegacy.frame.update(() => onDragEnd(event, info));\n        }\n    }\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", false);\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let 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    resolveConstraints() {\n        var _a;\n        const { dragConstraints, dragElastic } = this.getProps();\n        const layout = this.visualElement.projection &&\n            !this.visualElement.projection.layout\n            ? this.visualElement.projection.measure(false)\n            : (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout;\n        const prevConstraints = this.constraints;\n        if (dragConstraints && indexLegacy.isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.layoutBox, 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((axis) => {\n                if (this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !indexLegacy.isRefObject(constraints))\n            return false;\n        const constraintsElement = constraints.current;\n        indexLegacy.invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = indexLegacy.measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, 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            const userConstraints = onMeasureDragConstraints(indexLegacy.convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = indexLegacy.convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints && constraints[axis]) || {};\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            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\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    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        return axisValue.start(indexLegacy.animateMotionValue(axis, axisValue, 0, transition));\n    }\n    stopAnimation() {\n        eachAxis((axis) => this.getAxisMotionValue(axis).stop());\n    }\n    pauseAnimation() {\n        eachAxis((axis) => { var _a; return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.pause(); });\n    }\n    getAnimationState(axis) {\n        var _a;\n        return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.state;\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    getAxisMotionValue(axis) {\n        const dragKey = \"_drag\" + axis.toUpperCase();\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial ? props.initial[axis] : undefined) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                axisValue.set(point[axis] - indexLegacy.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    scalePositionWithinConstraints() {\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\n        if (!indexLegacy.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        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue) {\n                const 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        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        projection.root && projection.root.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((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(indexLegacy.mix(min, max, boxProgress[axis]));\n        });\n    }\n    addListeners() {\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            drag && dragListener && this.start(event);\n        });\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (indexLegacy.isRefObject(dragConstraints)) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            projection.root && projection.root.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        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const 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.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener && stopLayoutUpdateListener();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\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 = 10) {\n    let 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\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = indexLegacy.noop;\n        this.removeListeners = indexLegacy.noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || indexLegacy.noop;\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n    }\n}\n\nconst asyncHandler = (handler) => (event, info) => {\n    if (handler) {\n        indexLegacy.frame.update(() => handler(event, info));\n    }\n};\nclass PanGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removePointerDownListener = indexLegacy.noop;\n    }\n    onPointerDown(pointerDownEvent) {\n        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {\n            transformPagePoint: this.node.getTransformPagePoint(),\n            contextWindow: getContextWindow(this.node),\n        });\n    }\n    createPanHandlers() {\n        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();\n        return {\n            onSessionStart: asyncHandler(onPanSessionStart),\n            onStart: asyncHandler(onPanStart),\n            onMove: onPan,\n            onEnd: (event, info) => {\n                delete this.session;\n                if (onPanEnd) {\n                    indexLegacy.frame.update(() => onPanEnd(event, info));\n                }\n            },\n        };\n    }\n    mount() {\n        this.removePointerDownListener = addPointerEvent(this.node.current, \"pointerdown\", (event) => this.onPointerDown(event));\n    }\n    update() {\n        this.session && this.session.updateHandlers(this.createPanHandlers());\n    }\n    unmount() {\n        this.removePointerDownListener();\n        this.session && this.session.end();\n    }\n}\n\nconst borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nconst numBorders = borders.length;\nconst asNumber = (value) => typeof value === \"string\" ? parseFloat(value) : value;\nconst isPx = (value) => typeof value === \"number\" || indexLegacy.px.test(value);\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    if (shouldCrossfadeOpacity) {\n        target.opacity = indexLegacy.mix(0, \n        // TODO Reinstate this if only child\n        lead.opacity !== undefined ? lead.opacity : 1, easeCrossfadeIn(progress));\n        target.opacityExit = indexLegacy.mix(follow.opacity !== undefined ? follow.opacity : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = indexLegacy.mix(follow.opacity !== undefined ? follow.opacity : 1, lead.opacity !== undefined ? lead.opacity : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (let i = 0; i < numBorders; i++) {\n        const borderLabel = `border${borders[i]}Radius`;\n        let followRadius = getRadius(follow, borderLabel);\n        let leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        const canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(indexLegacy.mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (indexLegacy.percent.test(leadRadius) || indexLegacy.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 = indexLegacy.mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    return values[radiusName] !== undefined\n        ? values[radiusName]\n        : 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// }\nconst easeCrossfadeIn = compress(0, 0.5, indexLegacy.circOut);\nconst easeCrossfadeOut = compress(0.5, 0.95, indexLegacy.noop);\nfunction compress(min, max, easing) {\n    return (p) => {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(indexLegacy.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 = indexLegacy.scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = indexLegacy.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 = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {\n    if (indexLegacy.percent.test(translate)) {\n        translate = parseFloat(translate);\n        const relativeProgress = indexLegacy.mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    let originPoint = indexLegacy.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, [key, scaleKey, originKey], origin, sourceAxis) {\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 */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst 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 ? originBox.x : undefined, sourceBox ? sourceBox.x : undefined);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : undefined, sourceBox ? sourceBox.y : undefined);\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}\nfunction boxEqualsRounded(a, b) {\n    return (Math.round(a.x.min) === Math.round(b.x.min) &&\n        Math.round(a.x.max) === Math.round(b.x.max) &&\n        Math.round(a.y.min) === Math.round(b.y.min) &&\n        Math.round(a.y.max) === Math.round(b.y.max));\n}\nfunction aspectRatio(box) {\n    return calcLength(box.x) / calcLength(box.y);\n}\n\nclass NodeStack {\n    constructor() {\n        this.members = [];\n    }\n    add(node) {\n        indexLegacy.addUniqueItem(this.members, node);\n        node.scheduleRender();\n    }\n    remove(node) {\n        indexLegacy.removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            const prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    }\n    relegate(node) {\n        const indexOfNode = this.members.findIndex((member) => node === member);\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        let prevLead;\n        for (let i = indexOfNode; i >= 0; i--) {\n            const 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    promote(node, preserveFollowOpacity) {\n        const 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            }\n            if (node.root && node.root.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            const { crossfade } = node.options;\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    exitAnimationComplete() {\n        this.members.forEach((node) => {\n            const { options, resumingFrom } = node;\n            options.onExitComplete && options.onExitComplete();\n            if (resumingFrom) {\n                resumingFrom.options.onExitComplete &&\n                    resumingFrom.options.onExitComplete();\n            }\n        });\n    }\n    scheduleRender() {\n        this.members.forEach((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    removeLeadSnapshot() {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    }\n}\n\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    let transform = \"\";\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    const xTranslate = delta.x.translate / treeScale.x;\n    const yTranslate = delta.y.translate / treeScale.y;\n    if (xTranslate || yTranslate) {\n        transform = `translate3d(${xTranslate}px, ${yTranslate}px, 0) `;\n    }\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    if (treeScale.x !== 1 || treeScale.y !== 1) {\n        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;\n    }\n    if (latestTransform) {\n        const { rotate, rotateX, rotateY } = latestTransform;\n        if (rotate)\n            transform += `rotate(${rotate}deg) `;\n        if (rotateX)\n            transform += `rotateX(${rotateX}deg) `;\n        if (rotateY)\n            transform += `rotateY(${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    const elementScaleX = delta.x.scale * treeScale.x;\n    const elementScaleY = delta.y.scale * treeScale.y;\n    if (elementScaleX !== 1 || elementScaleY !== 1) {\n        transform += `scale(${elementScaleX}, ${elementScaleY})`;\n    }\n    return transform || \"none\";\n}\n\nconst compareByDepth = (a, b) => a.depth - b.depth;\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        indexLegacy.addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        indexLegacy.removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\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 */\nconst 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\nfunction record(data) {\n    if (window.MotionDebug) {\n        window.MotionDebug.record(data);\n    }\n}\n\nconst transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\nconst hiddenVisibility = { visibility: \"hidden\" };\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 */\nconst animationTarget = 1000;\nlet id$1 = 0;\n/**\n * Use a mutable data object for debug data so as to not create a new\n * object every frame.\n */\nconst projectionFrameData = {\n    type: \"projectionFrame\",\n    totalNodes: 0,\n    resolvedTargetDeltas: 0,\n    recalculatedProjection: 0,\n};\nfunction createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform, }) {\n    return class ProjectionNode {\n        constructor(latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {\n            /**\n             * A unique ID generated for every projection node.\n             */\n            this.id = id$1++;\n            /**\n             * An id that represents a unique session instigated by startUpdate.\n             */\n            this.animationId = 0;\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             * Flag to true if we think the projection calculations for this node needs\n             * recalculating as a result of an updated transform or layout animation.\n             */\n            this.isProjectionDirty = false;\n            /**\n             * Flag to true if the layout *or* transform has changed. This then gets propagated\n             * throughout the projection tree, forcing any element below to recalculate on the next frame.\n             */\n            this.isSharedProjectionDirty = false;\n            /**\n             * Flag transform dirty. This gets propagated throughout the whole tree but is only\n             * respected by shared nodes.\n             */\n            this.isTransformDirty = 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 layoutly\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            this.hasTreeAnimated = false;\n            // Note: Currently only running on root node\n            this.updateScheduled = false;\n            this.projectionUpdateScheduled = false;\n            this.checkUpdateFailed = () => {\n                if (this.isUpdating) {\n                    this.isUpdating = false;\n                    this.clearAllSnapshots();\n                }\n            };\n            /**\n             * This is a multi-step process as shared nodes might be of different depths. Nodes\n             * are sorted by depth order, so we need to resolve the entire tree before moving to\n             * the next step.\n             */\n            this.updateProjection = () => {\n                this.projectionUpdateScheduled = false;\n                /**\n                 * Reset debug counts. Manually resetting rather than creating a new\n                 * object each frame.\n                 */\n                projectionFrameData.totalNodes =\n                    projectionFrameData.resolvedTargetDeltas =\n                        projectionFrameData.recalculatedProjection =\n                            0;\n                this.nodes.forEach(propagateDirtyNodes);\n                this.nodes.forEach(resolveTargetDelta);\n                this.nodes.forEach(calcProjection);\n                this.nodes.forEach(cleanDirtyNodes);\n                record(projectionFrameData);\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.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? [...parent.path, parent] : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            for (let 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        addEventListener(name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new indexLegacy.SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        }\n        notifyListeners(name, ...args) {\n            const subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager && subscriptionManager.notify(...args);\n        }\n        hasListeners(name) {\n            return this.eventHandlers.has(name);\n        }\n        /**\n         * Lifecycles\n         */\n        mount(instance, isLayoutDirty = this.root.hasTreeAnimated) {\n            if (this.instance)\n                return;\n            this.isSVG = indexLegacy.isSVGElement(instance);\n            this.instance = instance;\n            const { layoutId, layout, visualElement } = this.options;\n            if (visualElement && !visualElement.current) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            this.parent && this.parent.children.add(this);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                let cancelDelay;\n                const resizeUnblockUpdate = () => (this.root.updateBlockedByResize = false);\n                attachResizeListener(instance, () => {\n                    this.root.updateBlockedByResize = true;\n                    cancelDelay && cancelDelay();\n                    cancelDelay = indexLegacy.delay(resizeUnblockUpdate, 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\", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout, }) => {\n                    if (this.isTreeAnimationBlocked()) {\n                        this.target = undefined;\n                        this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    const layoutTransition = this.options.transition ||\n                        visualElement.getDefaultTransition() ||\n                        defaultLayoutTransition;\n                    const { onLayoutAnimationStart, onLayoutAnimationComplete, } = visualElement.getProps();\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    const targetChanged = !this.targetLayout ||\n                        !boxEqualsRounded(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                    const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (this.options.layoutRoot ||\n                        (this.resumeFrom && this.resumeFrom.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                        const animationOptions = {\n                            ...indexLegacy.getValueTransition(layoutTransition, \"layout\"),\n                            onPlay: onLayoutAnimationStart,\n                            onComplete: onLayoutAnimationComplete,\n                        };\n                        if (visualElement.shouldReduceMotion ||\n                            this.options.layoutRoot) {\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                            finishAnimation(this);\n                        }\n                        if (this.isLead() && this.options.onExitComplete) {\n                            this.options.onExitComplete();\n                        }\n                    }\n                    this.targetLayout = newLayout;\n                });\n            }\n        }\n        unmount() {\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            const stack = this.getStack();\n            stack && stack.remove(this);\n            this.parent && this.parent.children.delete(this);\n            this.instance = undefined;\n            indexLegacy.cancelFrame(this.updateProjection);\n        }\n        // only on the root\n        blockUpdate() {\n            this.updateManuallyBlocked = true;\n        }\n        unblockUpdate() {\n            this.updateManuallyBlocked = false;\n        }\n        isUpdateBlocked() {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        }\n        isTreeAnimationBlocked() {\n            return (this.isAnimationBlocked ||\n                (this.parent && this.parent.isTreeAnimationBlocked()) ||\n                false);\n        }\n        // Note: currently only running on root node\n        startUpdate() {\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            this.nodes && this.nodes.forEach(resetRotation);\n            this.animationId++;\n        }\n        getTransformTemplate() {\n            const { visualElement } = this.options;\n            return visualElement && visualElement.getProps().transformTemplate;\n        }\n        willUpdate(shouldNotifyListeners = true) {\n            this.root.hasTreeAnimated = true;\n            if (this.root.isUpdateBlocked()) {\n                this.options.onExitComplete && this.options.onExitComplete();\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                node.shouldResetTransform = true;\n                node.updateScroll(\"snapshot\");\n                if (node.options.layoutRoot) {\n                    node.willUpdate(false);\n                }\n            }\n            const { layoutId, layout } = this.options;\n            if (layoutId === undefined && !layout)\n                return;\n            const transformTemplate = this.getTransformTemplate();\n            this.prevTransformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        }\n        update() {\n            this.updateScheduled = false;\n            const 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                this.nodes.forEach(clearIsLayoutDirty);\n            }\n            this.isUpdating = false;\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            /**\n             * Manually flush any pending updates. Ideally\n             * we could leave this to the following requestAnimationFrame but this seems\n             * to leave a flash of incorrectly styled content.\n             */\n            const now = performance.now();\n            indexLegacy.frameData.delta = indexLegacy.clamp(0, 1000 / 60, now - indexLegacy.frameData.timestamp);\n            indexLegacy.frameData.timestamp = now;\n            indexLegacy.frameData.isProcessing = true;\n            indexLegacy.steps.update.process(indexLegacy.frameData);\n            indexLegacy.steps.preRender.process(indexLegacy.frameData);\n            indexLegacy.steps.render.process(indexLegacy.frameData);\n            indexLegacy.frameData.isProcessing = false;\n        }\n        didUpdate() {\n            if (!this.updateScheduled) {\n                this.updateScheduled = true;\n                queueMicrotask(() => this.update());\n            }\n        }\n        clearAllSnapshots() {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        }\n        scheduleUpdateProjection() {\n            if (!this.projectionUpdateScheduled) {\n                this.projectionUpdateScheduled = true;\n                indexLegacy.frame.preRender(this.updateProjection, false, true);\n            }\n        }\n        scheduleCheckAfterUnmount() {\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            indexLegacy.frame.postRender(() => {\n                if (this.isLayoutDirty) {\n                    this.root.didUpdate();\n                }\n                else {\n                    this.root.checkUpdateFailed();\n                }\n            });\n        }\n        /**\n         * Update measurements\n         */\n        updateSnapshot() {\n            if (this.snapshot || !this.instance)\n                return;\n            this.snapshot = this.measure();\n        }\n        updateLayout() {\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 (let i = 0; i < this.path.length; i++) {\n                    const node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            const prevLayout = this.layout;\n            this.layout = this.measure(false);\n            this.layoutCorrected = indexLegacy.createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.layoutBox);\n            const { visualElement } = this.options;\n            visualElement &&\n                visualElement.notify(\"LayoutMeasure\", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : undefined);\n        }\n        updateScroll(phase = \"measure\") {\n            let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);\n            if (this.scroll &&\n                this.scroll.animationId === this.root.animationId &&\n                this.scroll.phase === phase) {\n                needsMeasurement = false;\n            }\n            if (needsMeasurement) {\n                this.scroll = {\n                    animationId: this.root.animationId,\n                    phase,\n                    isRoot: checkIsScrollRoot(this.instance),\n                    offset: measureScroll(this.instance),\n                };\n            }\n        }\n        resetTransform() {\n            if (!resetTransform)\n                return;\n            const isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            const transformTemplate = this.getTransformTemplate();\n            const transformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\n            const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    indexLegacy.hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        }\n        measure(removeTransform = true) {\n            const pageBox = this.measurePageBox();\n            let layoutBox = this.removeElementScroll(pageBox);\n            /**\n             * Measurements taken during the pre-render stage\n             * still have transforms applied so we remove them\n             * via calculation.\n             */\n            if (removeTransform) {\n                layoutBox = this.removeTransform(layoutBox);\n            }\n            roundBox(layoutBox);\n            return {\n                animationId: this.root.animationId,\n                measuredBox: pageBox,\n                layoutBox,\n                latestValues: {},\n                source: this.id,\n            };\n        }\n        measurePageBox() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return indexLegacy.createBox();\n            const box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            const { scroll } = this.root;\n            if (scroll) {\n                indexLegacy.translateAxis(box.x, scroll.offset.x);\n                indexLegacy.translateAxis(box.y, scroll.offset.y);\n            }\n            return box;\n        }\n        removeElementScroll(box) {\n            const boxWithoutScroll = indexLegacy.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 (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                const { scroll, options } = node;\n                if (node !== this.root && scroll && 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 (scroll.isRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        const { scroll: rootScroll } = this.root;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            indexLegacy.translateAxis(boxWithoutScroll.x, -rootScroll.offset.x);\n                            indexLegacy.translateAxis(boxWithoutScroll.y, -rootScroll.offset.y);\n                        }\n                    }\n                    indexLegacy.translateAxis(boxWithoutScroll.x, scroll.offset.x);\n                    indexLegacy.translateAxis(boxWithoutScroll.y, scroll.offset.y);\n                }\n            }\n            return boxWithoutScroll;\n        }\n        applyTransform(box, transformOnly = false) {\n            const withTransforms = indexLegacy.createBox();\n            copyBoxInto(withTransforms, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    indexLegacy.transformBox(withTransforms, {\n                        x: -node.scroll.offset.x,\n                        y: -node.scroll.offset.y,\n                    });\n                }\n                if (!indexLegacy.hasTransform(node.latestValues))\n                    continue;\n                indexLegacy.transformBox(withTransforms, node.latestValues);\n            }\n            if (indexLegacy.hasTransform(this.latestValues)) {\n                indexLegacy.transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        }\n        removeTransform(box) {\n            const boxWithoutTransform = indexLegacy.createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!indexLegacy.hasTransform(node.latestValues))\n                    continue;\n                indexLegacy.hasScale(node.latestValues) && node.updateSnapshot();\n                const sourceBox = indexLegacy.createBox();\n                const nodeBox = node.measurePageBox();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, node.snapshot ? node.snapshot.layoutBox : undefined, sourceBox);\n            }\n            if (indexLegacy.hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        }\n        setTargetDelta(delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n            this.isProjectionDirty = true;\n        }\n        setOptions(options) {\n            this.options = {\n                ...this.options,\n                ...options,\n                crossfade: options.crossfade !== undefined ? options.crossfade : true,\n            };\n        }\n        clearMeasurements() {\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        forceRelativeParentToResolveTarget() {\n            if (!this.relativeParent)\n                return;\n            /**\n             * If the parent target isn't up-to-date, force it to update.\n             * This is an unfortunate de-optimisation as it means any updating relative\n             * projection will cause all the relative parents to recalculate back\n             * up the tree.\n             */\n            if (this.relativeParent.resolvedRelativeTargetAt !==\n                indexLegacy.frameData.timestamp) {\n                this.relativeParent.resolveTargetDelta(true);\n            }\n        }\n        resolveTargetDelta(forceRecalculation = false) {\n            var _a;\n            /**\n             * Once the dirty status of nodes has been spread through the tree, we also\n             * need to check if we have a shared node of a different depth that has itself\n             * been dirtied.\n             */\n            const lead = this.getLead();\n            this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);\n            this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);\n            this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            /**\n             * We don't use transform for this step of processing so we don't\n             * need to check whether any nodes have changed transform.\n             */\n            const canSkip = !(forceRecalculation ||\n                (isShared && this.isSharedProjectionDirty) ||\n                this.isProjectionDirty ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty) ||\n                this.attemptToResolveRelativeTarget);\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\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            this.resolvedRelativeTargetAt = indexLegacy.frameData.timestamp;\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                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    relativeParent.layout &&\n                    this.animationProgress !== 1) {\n                    this.relativeParent = relativeParent;\n                    this.forceRelativeParentToResolveTarget();\n                    this.relativeTarget = indexLegacy.createBox();\n                    this.relativeTargetOrigin = indexLegacy.createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\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 = indexLegacy.createBox();\n                this.targetWithTransforms = indexLegacy.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                this.relativeParent &&\n                this.relativeParent.target) {\n                this.forceRelativeParentToResolveTarget();\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.layoutBox);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.layoutBox);\n                }\n                indexLegacy.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.layoutBox);\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                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    Boolean(relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !relativeParent.options.layoutScroll &&\n                    relativeParent.target &&\n                    this.animationProgress !== 1) {\n                    this.relativeParent = relativeParent;\n                    this.forceRelativeParentToResolveTarget();\n                    this.relativeTarget = indexLegacy.createBox();\n                    this.relativeTargetOrigin = indexLegacy.createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n            /**\n             * Increase debug counter for resolved target deltas\n             */\n            projectionFrameData.resolvedTargetDeltas++;\n        }\n        getClosestProjectingParent() {\n            if (!this.parent ||\n                indexLegacy.hasScale(this.parent.latestValues) ||\n                indexLegacy.has2DTranslate(this.parent.latestValues)) {\n                return undefined;\n            }\n            if (this.parent.isProjecting()) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        }\n        isProjecting() {\n            return Boolean((this.relativeTarget ||\n                this.targetDelta ||\n                this.options.layoutRoot) &&\n                this.layout);\n        }\n        calcProjection() {\n            var _a;\n            const lead = this.getLead();\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            let canSkip = true;\n            /**\n             * If this is a normal layout animation and neither this node nor its nearest projecting\n             * is dirty then we can't skip.\n             */\n            if (this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty)) {\n                canSkip = false;\n            }\n            /**\n             * If this is a shared layout animation and this node's shared projection is dirty then\n             * we can't skip.\n             */\n            if (isShared &&\n                (this.isSharedProjectionDirty || this.isTransformDirty)) {\n                canSkip = false;\n            }\n            /**\n             * If we have resolved the target this frame we must recalculate the\n             * projection to ensure it visually represents the internal calculations.\n             */\n            if (this.resolvedRelativeTargetAt === indexLegacy.frameData.timestamp) {\n                canSkip = false;\n            }\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\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((this.parent && this.parent.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            /**\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.layoutBox);\n            /**\n             * Record previous tree scales before updating.\n             */\n            const prevTreeScaleX = this.treeScale.x;\n            const prevTreeScaleY = this.treeScale.y;\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            indexLegacy.applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);\n            /**\n             * If this layer needs to perform scale correction but doesn't have a target,\n             * use the layout as the target.\n             */\n            if (lead.layout &&\n                !lead.target &&\n                (this.treeScale.x !== 1 || this.treeScale.y !== 1)) {\n                lead.target = lead.layout.layoutBox;\n            }\n            const { target } = lead;\n            if (!target) {\n                /**\n                 * If we don't have a target to project into, but we were previously\n                 * projecting, we want to remove the stored transform and schedule\n                 * a render to ensure the elements reflect the removed transform.\n                 */\n                if (this.projectionTransform) {\n                    this.projectionDelta = indexLegacy.createDelta();\n                    this.projectionTransform = \"none\";\n                    this.scheduleRender();\n                }\n                return;\n            }\n            if (!this.projectionDelta) {\n                this.projectionDelta = indexLegacy.createDelta();\n                this.projectionDeltaWithTransform = indexLegacy.createDelta();\n            }\n            const 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             * Increase debug counter for recalculated projections\n             */\n            projectionFrameData.recalculatedProjection++;\n        }\n        hide() {\n            this.isVisible = false;\n            // TODO: Schedule render\n        }\n        show() {\n            this.isVisible = true;\n            // TODO: Schedule render\n        }\n        scheduleRender(notifyAll = true) {\n            this.options.scheduleRender && this.options.scheduleRender();\n            if (notifyAll) {\n                const stack = this.getStack();\n                stack && stack.scheduleRender();\n            }\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        }\n        setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {\n            const snapshot = this.snapshot;\n            const snapshotLatestValues = snapshot\n                ? snapshot.latestValues\n                : {};\n            const mixedValues = { ...this.latestValues };\n            const targetDelta = indexLegacy.createDelta();\n            if (!this.relativeParent ||\n                !this.relativeParent.options.layoutRoot) {\n                this.relativeTarget = this.relativeTargetOrigin = undefined;\n            }\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            const relativeLayout = indexLegacy.createBox();\n            const snapshotSource = snapshot ? snapshot.source : undefined;\n            const layoutSource = this.layout ? this.layout.source : undefined;\n            const isSharedLayoutAnimation = snapshotSource !== layoutSource;\n            const stack = this.getStack();\n            const isOnlyMember = !stack || stack.members.length <= 1;\n            const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            let prevRelativeTarget;\n            this.mixTargetDelta = (latest) => {\n                const 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                    this.relativeParent &&\n                    this.relativeParent.layout) {\n                    calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);\n                    mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);\n                    /**\n                     * If this is an unchanged relative target we can consider the\n                     * projection not dirty.\n                     */\n                    if (prevRelativeTarget &&\n                        boxEquals(this.relativeTarget, prevRelativeTarget)) {\n                        this.isProjectionDirty = false;\n                    }\n                    if (!prevRelativeTarget)\n                        prevRelativeTarget = indexLegacy.createBox();\n                    copyBoxInto(prevRelativeTarget, this.relativeTarget);\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(this.options.layoutRoot ? 1000 : 0);\n        }\n        startAnimation(options) {\n            this.notifyListeners(\"animationStart\");\n            this.currentAnimation && this.currentAnimation.stop();\n            if (this.resumingFrom && this.resumingFrom.currentAnimation) {\n                this.resumingFrom.currentAnimation.stop();\n            }\n            if (this.pendingAnimation) {\n                indexLegacy.cancelFrame(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 = indexLegacy.frame.update(() => {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                this.currentAnimation = indexLegacy.animateSingleValue(0, animationTarget, {\n                    ...options,\n                    onUpdate: (latest) => {\n                        this.mixTargetDelta(latest);\n                        options.onUpdate && options.onUpdate(latest);\n                    },\n                    onComplete: () => {\n                        options.onComplete && options.onComplete();\n                        this.completeAnimation();\n                    },\n                });\n                if (this.resumingFrom) {\n                    this.resumingFrom.currentAnimation = this.currentAnimation;\n                }\n                this.pendingAnimation = undefined;\n            });\n        }\n        completeAnimation() {\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            const stack = this.getStack();\n            stack && stack.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        }\n        finishAnimation() {\n            if (this.currentAnimation) {\n                this.mixTargetDelta && this.mixTargetDelta(animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        }\n        applyTransformsToTarget() {\n            const lead = this.getLead();\n            let { targetWithTransforms, target, layout, latestValues } = lead;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            /**\n             * If we're only animating position, and this element isn't the lead element,\n             * then instead of projecting into the lead box we instead want to calculate\n             * a new target that aligns the two boxes but maintains the layout shape.\n             */\n            if (this !== lead &&\n                this.layout &&\n                layout &&\n                shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {\n                target = this.target || indexLegacy.createBox();\n                const xLength = calcLength(this.layout.layoutBox.x);\n                target.x.min = lead.target.x.min;\n                target.x.max = target.x.min + xLength;\n                const yLength = calcLength(this.layout.layoutBox.y);\n                target.y.min = lead.target.y.min;\n                target.y.max = target.y.min + yLength;\n            }\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            indexLegacy.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 layout layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        }\n        registerSharedNode(layoutId, node) {\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            const stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            const config = node.options.initialPromotionConfig;\n            node.promote({\n                transition: config ? config.transition : undefined,\n                preserveFollowOpacity: config && config.shouldPreserveFollowOpacity\n                    ? config.shouldPreserveFollowOpacity(node)\n                    : undefined,\n            });\n        }\n        isLead() {\n            const stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        }\n        getLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        }\n        getPrevLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        }\n        getStack() {\n            const { layoutId } = this.options;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        }\n        promote({ needsReset, transition, preserveFollowOpacity, } = {}) {\n            const 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 });\n        }\n        relegate() {\n            const stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        }\n        resetRotation() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            let hasRotate = false;\n            /**\n             * An unrolled check for rotation values. Most elements don't have any rotation and\n             * skipping the nested loop and new object creation is 50% faster.\n             */\n            const { latestValues } = visualElement;\n            if (latestValues.rotate ||\n                latestValues.rotateX ||\n                latestValues.rotateY ||\n                latestValues.rotateZ) {\n                hasRotate = true;\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            const resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (let i = 0; i < transformAxes.length; i++) {\n                const key = \"rotate\" + transformAxes[i];\n                // Record the rotation and then temporarily set it to 0\n                if (latestValues[key]) {\n                    resetValues[key] = latestValues[key];\n                    visualElement.setStaticValue(key, 0);\n                }\n            }\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement.render();\n            // Put back all the values we reset\n            for (const 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        getProjectionStyles(styleProp) {\n            var _a, _b;\n            if (!this.instance || this.isSVG)\n                return undefined;\n            if (!this.isVisible) {\n                return hiddenVisibility;\n            }\n            const styles = {\n                visibility: \"\",\n            };\n            const transformTemplate = this.getTransformTemplate();\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            const lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                const emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity =\n                        this.latestValues.opacity !== undefined\n                            ? this.latestValues.opacity\n                            : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !indexLegacy.hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            const 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            const { x, y } = this.projectionDelta;\n            styles.transformOrigin = `${x.origin * 100}% ${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                        ? (_b = (_a = valuesToRender.opacity) !== null && _a !== void 0 ? _a : this.latestValues.opacity) !== null && _b !== void 0 ? _b : 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 layout\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? valuesToRender.opacity !== undefined\n                            ? valuesToRender.opacity\n                            : \"\"\n                        : valuesToRender.opacityExit !== undefined\n                            ? valuesToRender.opacityExit\n                            : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (const key in indexLegacy.scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                const { correct, applyTo } = indexLegacy.scaleCorrectors[key];\n                /**\n                 * Only apply scale correction to the value if we have an\n                 * active projection transform. Otherwise these values become\n                 * vulnerable to distortion if the element changes size without\n                 * a corresponding layout animation.\n                 */\n                const corrected = styles.transform === \"none\"\n                    ? valuesToRender[key]\n                    : correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    const num = applyTo.length;\n                    for (let 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 === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        }\n        clearSnapshot() {\n            this.resumeFrom = this.snapshot = undefined;\n        }\n        // Only run on root\n        resetTree() {\n            this.root.nodes.forEach((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    };\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a;\n    const snapshot = ((_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;\n        const { animationType } = node.options;\n        const isShared = snapshot.source !== node.layout.source;\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 (animationType === \"size\") {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(layout[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n                /**\n                 * Ensure relative target gets resized and rerendererd\n                 */\n                if (node.relativeTarget && !node.currentAnimation) {\n                    node.isProjectionDirty = true;\n                    node.relativeTarget[axis].max =\n                        node.relativeTarget[axis].min + length;\n                }\n            });\n        }\n        const layoutDelta = indexLegacy.createDelta();\n        calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);\n        const visualDelta = indexLegacy.createDelta();\n        if (isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout, snapshot.layoutBox);\n        }\n        const hasLayoutChanged = !isDeltaZero(layoutDelta);\n        let hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            const 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 (relativeParent && !relativeParent.resumeFrom) {\n                const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;\n                if (parentSnapshot && parentLayout) {\n                    const relativeSnapshot = indexLegacy.createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);\n                    const relativeLayout = indexLegacy.createBox();\n                    calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox);\n                    if (!boxEqualsRounded(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                    if (relativeParent.options.layoutRoot) {\n                        node.relativeTarget = relativeLayout;\n                        node.relativeTargetOrigin = relativeSnapshot;\n                        node.relativeParent = relativeParent;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout,\n            snapshot,\n            delta: visualDelta,\n            layoutDelta,\n            hasLayoutChanged,\n            hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        const { onExitComplete } = node.options;\n        onExitComplete && onExitComplete();\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 propagateDirtyNodes(node) {\n    /**\n     * Increase debug counter for nodes encountered this frame\n     */\n    projectionFrameData.totalNodes++;\n    if (!node.parent)\n        return;\n    /**\n     * If this node isn't projecting, propagate isProjectionDirty. It will have\n     * no performance impact but it will allow the next child that *is* projecting\n     * but *isn't* dirty to just check its parent to see if *any* ancestor needs\n     * correcting.\n     */\n    if (!node.isProjecting()) {\n        node.isProjectionDirty = node.parent.isProjectionDirty;\n    }\n    /**\n     * Propagate isSharedProjectionDirty and isTransformDirty\n     * throughout the whole tree. A future revision can take another look at\n     * this but for safety we still recalcualte shared nodes.\n     */\n    node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty ||\n        node.parent.isProjectionDirty ||\n        node.parent.isSharedProjectionDirty));\n    node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);\n}\nfunction cleanDirtyNodes(node) {\n    node.isProjectionDirty =\n        node.isSharedProjectionDirty =\n            node.isTransformDirty =\n                false;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction clearIsLayoutDirty(node) {\n    node.isLayoutDirty = false;\n}\nfunction resetTransformStyle(node) {\n    const { visualElement } = node.options;\n    if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notify(\"BeforeLayoutMeasure\");\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n    node.isProjectionDirty = true;\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 = indexLegacy.mix(delta.translate, 0, p);\n    output.scale = indexLegacy.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 = indexLegacy.mix(from.min, to.min, p);\n    output.max = indexLegacy.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}\nconst defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nconst userAgentContains = (string) => typeof navigator !== \"undefined\" &&\n    navigator.userAgent.toLowerCase().includes(string);\n/**\n * Measured bounding boxes must be rounded in Safari and\n * left untouched in Chrome, otherwise non-integer layouts within scaled-up elements\n * can appear to jump.\n */\nconst roundPoint = userAgentContains(\"applewebkit/\") && !userAgentContains(\"chrome/\")\n    ? Math.round\n    : indexLegacy.noop;\nfunction roundAxis(axis) {\n    // Round to the nearest .5 pixels to support subpixel layouts\n    axis.min = roundPoint(axis.min);\n    axis.max = roundPoint(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\nfunction shouldAnimatePositionOnly(animationType, snapshot, layout) {\n    return (animationType === \"position\" ||\n        (animationType === \"preserve-aspect\" &&\n            !isNear(aspectRatio(snapshot), aspectRatio(layout), 0.2)));\n}\n\nconst DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: (ref, notify) => addDomEvent(ref, \"resize\", notify),\n    measureScroll: () => ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }),\n    checkIsScrollRoot: () => true,\n});\n\nconst rootProjectionNode = {\n    current: undefined,\n};\nconst HTMLProjectionNode = createProjectionNode({\n    measureScroll: (instance) => ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }),\n    defaultParent: () => {\n        if (!rootProjectionNode.current) {\n            const documentNode = new DocumentProjectionNode({});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: (instance, value) => {\n        instance.style.transform = value !== undefined ? value : \"none\";\n    },\n    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === \"fixed\"),\n});\n\nconst notify = (node) => !node.isLayoutDirty && node.willUpdate(false);\nfunction nodeGroup() {\n    const nodes = new Set();\n    const subscriptions = new WeakMap();\n    const dirtyAll = () => nodes.forEach(notify);\n    return {\n        add: (node) => {\n            nodes.add(node);\n            subscriptions.set(node, node.addEventListener(\"willUpdate\", dirtyAll));\n        },\n        remove: (node) => {\n            nodes.delete(node);\n            const unsubscribe = subscriptions.get(node);\n            if (unsubscribe) {\n                unsubscribe();\n                subscriptions.delete(node);\n            }\n            dirtyAll();\n        },\n        dirty: dirtyAll,\n    };\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 */\nconst correctBorderRadius = {\n    correct: (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 (indexLegacy.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        const x = pixelsToPercent(latest, node.target.x);\n        const y = pixelsToPercent(latest, node.target.y);\n        return `${x}% ${y}%`;\n    },\n};\n\nconst correctBoxShadow = {\n    correct: (latest, { treeScale, projectionDelta }) => {\n        const original = latest;\n        const shadow = indexLegacy.complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        const template = indexLegacy.complex.createTransformer(latest);\n        const offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        const xScale = projectionDelta.x.scale * treeScale.x;\n        const 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        const averageScale = indexLegacy.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        return template(shadow);\n    },\n};\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    const context = React.useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    const { isPresent, onExitComplete, register } = context;\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    const id = React.useId();\n    React.useEffect(() => register(id), []);\n    const safeToRemove = () => onExitComplete && 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\nclass MeasureLayoutWithContext extends React__default[\"default\"].Component {\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    componentDidMount() {\n        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;\n        const { projection } = visualElement;\n        indexLegacy.addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", () => {\n                this.safeToRemove();\n            });\n            projection.setOptions({\n                ...projection.options,\n                onExitComplete: () => this.safeToRemove(),\n            });\n        }\n        globalProjectionState.hasEverUpdated = true;\n    }\n    getSnapshotBeforeUpdate(prevProps) {\n        const { layoutDependency, visualElement, drag, isPresent } = this.props;\n        const 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                indexLegacy.frame.postRender(() => {\n                    const stack = projection.getStack();\n                    if (!stack || !stack.members.length) {\n                        this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    }\n    componentDidUpdate() {\n        const { projection } = this.props.visualElement;\n        if (projection) {\n            projection.root.didUpdate();\n            queueMicrotask(() => {\n                if (!projection.currentAnimation && projection.isLead()) {\n                    this.safeToRemove();\n                }\n            });\n        }\n    }\n    componentWillUnmount() {\n        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;\n        const { projection } = visualElement;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup && layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext && promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    }\n    safeToRemove() {\n        const { safeToRemove } = this.props;\n        safeToRemove && safeToRemove();\n    }\n    render() {\n        return null;\n    }\n}\nfunction MeasureLayout(props) {\n    const [isPresent, safeToRemove] = usePresence();\n    const layoutGroup = React.useContext(LayoutGroupContext);\n    return (React__default[\"default\"].createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: React.useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));\n}\nconst defaultScaleCorrectors = {\n    borderRadius: {\n        ...correctBorderRadius,\n        applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ],\n    },\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nconst drag = {\n    pan: {\n        Feature: PanGesture,\n    },\n    drag: {\n        Feature: DragGesture,\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new indexLegacy.SVGVisualElement(options, { enableHardwareAcceleration: false })\n        : new indexLegacy.HTMLVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nconst layout = {\n    layout: {\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nconst preloadedFeatures = {\n    ...animations,\n    ...gestureAnimations,\n    ...drag,\n    ...layout,\n};\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nconst motion = /*@__PURE__*/ createMotionProxy((Component, config) => createDomMotionConfig(Component, config, preloadedFeatures, createDomVisualElement));\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, preloadedFeatures, createDomVisualElement));\n}\n\n/**\n * @public\n */\nconst m = createMotionProxy(createDomMotionConfig);\n\nfunction useIsMounted() {\n    const isMounted = React.useRef(false);\n    useIsomorphicLayoutEffect(() => {\n        isMounted.current = true;\n        return () => {\n            isMounted.current = false;\n        };\n    }, []);\n    return isMounted;\n}\n\nfunction useForceUpdate() {\n    const isMounted = useIsMounted();\n    const [forcedRenderCount, setForcedRenderCount] = React.useState(0);\n    const forceRender = React.useCallback(() => {\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    const deferredForceRender = React.useCallback(() => indexLegacy.frame.postRender(forceRender), [forceRender]);\n    return [deferredForceRender, forcedRenderCount];\n}\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React__namespace.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent }) {\n    const id = React.useId();\n    const ref = React.useRef(null);\n    const size = React.useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n    });\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    React.useInsertionEffect(() => {\n        const { width, height, top, left } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        document.head.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            top: ${top}px !important;\n            left: ${left}px !important;\n          }\n        `);\n        }\n        return () => {\n            document.head.removeChild(style);\n        };\n    }, [isPresent]);\n    return (React__namespace.createElement(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size }, React__namespace.cloneElement(children, { ref })));\n}\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = React.useId();\n    const context = React.useMemo(() => ({\n        id,\n        initial,\n        isPresent,\n        custom,\n        onExitComplete: (childId) => {\n            presenceChildren.set(childId, true);\n            for (const isComplete of presenceChildren.values()) {\n                if (!isComplete)\n                    return; // can stop searching when any is incomplete\n            }\n            onExitComplete && onExitComplete();\n        },\n        register: (childId) => {\n            presenceChildren.set(childId, false);\n            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(() => {\n        presenceChildren.forEach((_, key) => 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(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = React__namespace.createElement(PopChild, { isPresent: isPresent }, children);\n    }\n    return (React__namespace.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nfunction useUnmountEffect(callback) {\n    return React.useEffect(() => () => callback(), []);\n}\n\nconst getChildKey = (child) => child.key || \"\";\nfunction updateChildLookup(children, allChildren) {\n    children.forEach((child) => {\n        const key = getChildKey(child);\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    const filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    React.Children.forEach(children, (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 */\nconst AnimatePresence = ({ children, custom, initial = true, onExitComplete, exitBeforeEnter, presenceAffectsLayout = true, mode = \"sync\", }) => {\n    indexLegacy.invariant(!exitBeforeEnter, \"Replace exitBeforeEnter with mode='wait'\");\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    const forceRender = React.useContext(LayoutGroupContext).forceRender || useForceUpdate()[0];\n    const isMounted = useIsMounted();\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    const filteredChildren = onlyElements(children);\n    let childrenToRender = filteredChildren;\n    const exitingChildren = React.useRef(new Map()).current;\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    const presentChildren = React.useRef(childrenToRender);\n    // A lookup table to quickly reference components by key\n    const 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    const isInitialRender = React.useRef(true);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        updateChildLookup(filteredChildren, allChildren);\n        presentChildren.current = childrenToRender;\n    });\n    useUnmountEffect(() => {\n        isInitialRender.current = true;\n        allChildren.clear();\n        exitingChildren.clear();\n    });\n    if (isInitialRender.current) {\n        return (React__namespace.createElement(React__namespace.Fragment, null, childrenToRender.map((child) => (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child)))));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    childrenToRender = [...childrenToRender];\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    const presentKeys = presentChildren.current.map(getChildKey);\n    const targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    const numPresent = presentKeys.length;\n    for (let i = 0; i < numPresent; i++) {\n        const key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1 && !exitingChildren.has(key)) {\n            exitingChildren.set(key, undefined);\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 (mode === \"wait\" && exitingChildren.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    exitingChildren.forEach((component, key) => {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        const child = allChildren.get(key);\n        if (!child)\n            return;\n        const insertionIndex = presentKeys.indexOf(key);\n        let exitingComponent = component;\n        if (!exitingComponent) {\n            const onExit = () => {\n                // clean up the exiting children map\n                exitingChildren.delete(key);\n                // compute the keys of children that were rendered once but are no longer present\n                // this could happen in case of too many fast consequent renderings\n                // @link https://github.com/framer/motion/issues/2023\n                const leftOverKeys = Array.from(allChildren.keys()).filter((childKey) => !targetKeys.includes(childKey));\n                // clean up the all children map\n                leftOverKeys.forEach((leftOverKey) => allChildren.delete(leftOverKey));\n                // make sure to render only the children that are actually visible\n                presentChildren.current = filteredChildren.filter((presentChild) => {\n                    const presentChildKey = getChildKey(presentChild);\n                    return (\n                    // filter out the node exiting\n                    presentChildKey === key ||\n                        // filter out the leftover children\n                        leftOverKeys.includes(presentChildKey));\n                });\n                // Defer re-rendering until all exiting children have indeed left\n                if (!exitingChildren.size) {\n                    if (isMounted.current === false)\n                        return;\n                    forceRender();\n                    onExitComplete && onExitComplete();\n                }\n            };\n            exitingComponent = (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));\n            exitingChildren.set(key, exitingComponent);\n        }\n        childrenToRender.splice(insertionIndex, 0, exitingComponent);\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((child) => {\n        const key = child.key;\n        return exitingChildren.has(key) ? (child) : (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));\n    });\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        childrenToRender.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    return (React__namespace.createElement(React__namespace.Fragment, null, exitingChildren.size\n        ? childrenToRender\n        : childrenToRender.map((child) => React.cloneElement(child))));\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({ children, isValidProp, ...config }) {\n    isValidProp && loadExternalIsValidProp(isValidProp);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = { ...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(() => 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    const context = React.useMemo(() => 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, domAnimation } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimation}>\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/domAnimation')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion({ children, features, strict = false }) {\n    const [, setIsLoaded] = React.useState(!isLazyBundle(features));\n    const loadedRenderer = React.useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        const { renderer, ...loadedFeatures } = features;\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    React.useEffect(() => {\n        if (isLazyBundle(features)) {\n            features().then(({ renderer, ...loadedFeatures }) => {\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 } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\n/**\n * Note: Still used by components generated by old versions of Framer\n *\n * @deprecated\n */\nconst DeprecatedLayoutGroupContext = React.createContext(null);\n\nconst shouldInheritGroup = (inherit) => inherit === true;\nconst shouldInheritId = (inherit) => shouldInheritGroup(inherit === true) || inherit === \"id\";\nconst LayoutGroup = ({ children, id, inherit = true }) => {\n    const layoutGroupContext = React.useContext(LayoutGroupContext);\n    const deprecatedLayoutGroupContext = React.useContext(DeprecatedLayoutGroupContext);\n    const [forceRender, key] = useForceUpdate();\n    const context = React.useRef(null);\n    const upstreamId = layoutGroupContext.id || deprecatedLayoutGroupContext;\n    if (context.current === null) {\n        if (shouldInheritId(inherit) && upstreamId) {\n            id = id ? upstreamId + \"-\" + id : upstreamId;\n        }\n        context.current = {\n            id,\n            group: shouldInheritGroup(inherit)\n                ? layoutGroupContext.group || nodeGroup()\n                : nodeGroup(),\n        };\n    }\n    const memoizedContext = React.useMemo(() => ({ ...context.current, forceRender }), [key]);\n    return (React__namespace.createElement(LayoutGroupContext.Provider, { value: memoizedContext }, children));\n};\n\nconst ReorderContext = React.createContext(null);\n\nfunction checkReorder(order, value, offset, velocity) {\n    if (!velocity)\n        return order;\n    const index = order.findIndex((item) => item.value === value);\n    if (index === -1)\n        return order;\n    const nextOffset = velocity > 0 ? 1 : -1;\n    const nextItem = order[index + nextOffset];\n    if (!nextItem)\n        return order;\n    const item = order[index];\n    const nextLayout = nextItem.layout;\n    const nextItemCenter = indexLegacy.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 indexLegacy.moveItem(order, index, index + nextOffset);\n    }\n    return order;\n}\n\nfunction ReorderGroup({ children, as = \"ul\", axis = \"y\", onReorder, values, ...props }, externalRef) {\n    const Component = useConstant(() => motion(as));\n    const order = [];\n    const isReordering = React.useRef(false);\n    indexLegacy.invariant(Boolean(values), \"Reorder.Group must be provided a values prop\");\n    const context = {\n        axis,\n        registerItem: (value, layout) => {\n            // If the entry was already added, update it rather than adding it again\n            const idx = order.findIndex((entry) => value === entry.value);\n            if (idx !== -1) {\n                order[idx].layout = layout[axis];\n            }\n            else {\n                order.push({ value: value, layout: layout[axis] });\n            }\n            order.sort(compareMin);\n        },\n        updateOrder: (item, offset, velocity) => {\n            if (isReordering.current)\n                return;\n            const newOrder = checkReorder(order, item, offset, velocity);\n            if (order !== newOrder) {\n                isReordering.current = true;\n                onReorder(newOrder\n                    .map(getValue)\n                    .filter((value) => values.indexOf(value) !== -1));\n            }\n        },\n    };\n    React.useEffect(() => {\n        isReordering.current = false;\n    });\n    return (React__namespace.createElement(Component, { ...props, ref: externalRef, ignoreStrict: true },\n        React__namespace.createElement(ReorderContext.Provider, { value: context }, children)));\n}\nconst 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    const value = useConstant(() => indexLegacy.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    const { isStatic } = React.useContext(MotionConfigContext);\n    if (isStatic) {\n        const [, setLatest] = React.useState(initial);\n        React.useEffect(() => value.on(\"change\", setLatest), []);\n    }\n    return value;\n}\n\nfunction useCombineMotionValues(values, combineValues) {\n    /**\n     * Initialise the returned motion value. This remains the same between renders.\n     */\n    const 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    const updateValue = () => 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    useIsomorphicLayoutEffect(() => {\n        const scheduleUpdate = () => indexLegacy.frame.update(updateValue, false, true);\n        const subscriptions = values.map((v) => v.on(\"change\", scheduleUpdate));\n        return () => {\n            subscriptions.forEach((unsubscribe) => unsubscribe());\n            indexLegacy.cancelFrame(updateValue);\n        };\n    });\n    return value;\n}\n\nfunction useComputed(compute) {\n    /**\n     * Open session of collectMotionValues. Any MotionValue that calls get()\n     * will be saved into this array.\n     */\n    indexLegacy.collectMotionValues.current = [];\n    compute();\n    const value = useCombineMotionValues(indexLegacy.collectMotionValues.current, compute);\n    /**\n     * Synchronously close session of collectMotionValues.\n     */\n    indexLegacy.collectMotionValues.current = undefined;\n    return value;\n}\n\nfunction useTransform(input, inputRangeOrTransformer, outputRange, options) {\n    if (typeof input === \"function\") {\n        return useComputed(input);\n    }\n    const transformer = typeof inputRangeOrTransformer === \"function\"\n        ? inputRangeOrTransformer\n        : indexLegacy.transform(inputRangeOrTransformer, outputRange, options);\n    return Array.isArray(input)\n        ? useListTransform(input, transformer)\n        : useListTransform([input], ([latest]) => transformer(latest));\n}\nfunction useListTransform(values, transformer) {\n    const latest = useConstant(() => []);\n    return useCombineMotionValues(values, () => {\n        latest.length = 0;\n        const numValues = values.length;\n        for (let i = 0; i < numValues; i++) {\n            latest[i] = values[i].get();\n        }\n        return transformer(latest);\n    });\n}\n\nfunction useDefaultMotionValue(value, defaultValue = 0) {\n    return indexLegacy.isMotionValue(value) ? value : useMotionValue(defaultValue);\n}\nfunction ReorderItem({ children, style = {}, value, as = \"li\", onDrag, layout = true, ...props }, externalRef) {\n    const Component = useConstant(() => motion(as));\n    const context = React.useContext(ReorderContext);\n    const point = {\n        x: useDefaultMotionValue(style.x),\n        y: useDefaultMotionValue(style.y),\n    };\n    const zIndex = useTransform([point.x, point.y], ([latestX, latestY]) => latestX || latestY ? 1 : \"unset\");\n    indexLegacy.invariant(Boolean(context), \"Reorder.Item must be a child of Reorder.Group\");\n    const { axis, registerItem, updateOrder } = context;\n    return (React__namespace.createElement(Component, { drag: axis, ...props, dragSnapToOrigin: true, style: { ...style, x: point.x, y: point.y, zIndex }, layout: layout, onDrag: (event, gesturePoint) => {\n            const { velocity } = gesturePoint;\n            velocity[axis] &&\n                updateOrder(value, point[axis].get(), velocity[axis]);\n            onDrag && onDrag(event, gesturePoint);\n        }, onLayoutMeasure: (measured) => registerItem(value, measured), ref: externalRef, ignoreStrict: true }, children));\n}\nconst Item = React.forwardRef(ReorderItem);\n\nconst Reorder = {\n    Group,\n    Item,\n};\n\n/**\n * @public\n */\nconst domAnimation = {\n    renderer: createDomVisualElement,\n    ...animations,\n    ...gestureAnimations,\n};\n\n/**\n * @public\n */\nconst domMax = {\n    ...domAnimation,\n    ...drag,\n    ...layout,\n};\n\n/**\n * Combine multiple motion values into a new one using a string template literal.\n *\n * ```jsx\n * import {\n *   motion,\n *   useSpring,\n *   useMotionValue,\n *   useMotionTemplate\n * } from \"framer-motion\"\n *\n * function Component() {\n *   const shadowX = useSpring(0)\n *   const shadowY = useMotionValue(0)\n *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`\n *\n *   return <motion.div style={{ filter: shadow }} />\n * }\n * ```\n *\n * @public\n */\nfunction useMotionTemplate(fragments, ...values) {\n    /**\n     * Create a function that will build a string from the latest motion values.\n     */\n    const numFragments = fragments.length;\n    function buildValue() {\n        let output = ``;\n        for (let i = 0; i < numFragments; i++) {\n            output += fragments[i];\n            const value = values[i];\n            if (value) {\n                output += indexLegacy.isMotionValue(value) ? value.get() : value;\n            }\n        }\n        return output;\n    }\n    return useCombineMotionValues(values.filter(indexLegacy.isMotionValue), 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    const { isStatic } = React.useContext(MotionConfigContext);\n    const activeSpringAnimation = React.useRef(null);\n    const value = useMotionValue(indexLegacy.isMotionValue(source) ? source.get() : source);\n    const stopAnimation = () => {\n        if (activeSpringAnimation.current) {\n            activeSpringAnimation.current.stop();\n        }\n    };\n    React.useInsertionEffect(() => {\n        return value.attach((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            stopAnimation();\n            activeSpringAnimation.current = indexLegacy.animateValue({\n                keyframes: [value.get(), v],\n                velocity: value.getVelocity(),\n                type: \"spring\",\n                restDelta: 0.001,\n                restSpeed: 0.01,\n                ...config,\n                onUpdate: set,\n            });\n            /**\n             * If we're between frames, resync the animation to the frameloop.\n             */\n            if (!indexLegacy.frameData.isProcessing) {\n                const delta = performance.now() - indexLegacy.frameData.timestamp;\n                if (delta < 30) {\n                    activeSpringAnimation.current.time =\n                        indexLegacy.millisecondsToSeconds(delta);\n                }\n            }\n            return value.get();\n        }, stopAnimation);\n    }, [JSON.stringify(config)]);\n    useIsomorphicLayoutEffect(() => {\n        if (indexLegacy.isMotionValue(source)) {\n            return source.on(\"change\", (v) => value.set(parseFloat(v)));\n        }\n    }, [value]);\n    return value;\n}\n\nfunction useMotionValueEvent(value, event, callback) {\n    /**\n     * useInsertionEffect will create subscriptions before any other\n     * effects will run. Effects run upwards through the tree so it\n     * can be that binding a useLayoutEffect higher up the tree can\n     * miss changes from lower down the tree.\n     */\n    React.useInsertionEffect(() => value.on(event, callback), [value, event, callback]);\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    const velocity = useMotionValue(value.getVelocity());\n    useMotionValueEvent(value, \"velocityChange\", (newVelocity) => {\n        velocity.set(newVelocity);\n    });\n    return velocity;\n}\n\nfunction refWarning(name, ref) {\n    indexLegacy.warning(Boolean(!ref || ref.current), `You have defined a ${name} options but the provided ref is not yet hydrated, probably because it's defined higher up the tree. Try calling useScroll() in the same component as the ref, or setting its \\`layoutEffect: false\\` option.`);\n}\nconst createScrollMotionValues = () => ({\n    scrollX: indexLegacy.motionValue(0),\n    scrollY: indexLegacy.motionValue(0),\n    scrollXProgress: indexLegacy.motionValue(0),\n    scrollYProgress: indexLegacy.motionValue(0),\n});\nfunction useScroll({ container, target, layoutEffect = true, ...options } = {}) {\n    const values = useConstant(createScrollMotionValues);\n    const useLifecycleEffect = layoutEffect\n        ? useIsomorphicLayoutEffect\n        : React.useEffect;\n    useLifecycleEffect(() => {\n        refWarning(\"target\", target);\n        refWarning(\"container\", container);\n        return indexLegacy.scrollInfo(({ x, 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        }, {\n            ...options,\n            container: (container === null || container === void 0 ? void 0 : container.current) || undefined,\n            target: (target === null || target === void 0 ? void 0 : target.current) || undefined,\n        });\n    }, [container, target, JSON.stringify(options.offset)]);\n    return values;\n}\n\n/**\n * @deprecated useElementScroll is deprecated. Convert to useScroll({ container: ref })\n */\nfunction useElementScroll(ref) {\n    if (process.env.NODE_ENV === \"development\") {\n        indexLegacy.warnOnce(false, \"useElementScroll is deprecated. Convert to useScroll({ container: ref }).\");\n    }\n    return useScroll({ container: ref });\n}\n\n/**\n * @deprecated useViewportScroll is deprecated. Convert to useScroll()\n */\nfunction useViewportScroll() {\n    if (process.env.NODE_ENV !== \"production\") {\n        indexLegacy.warnOnce(false, \"useViewportScroll is deprecated. Convert to useScroll().\");\n    }\n    return useScroll();\n}\n\nfunction useAnimationFrame(callback) {\n    const initialTimestamp = React.useRef(0);\n    const { isStatic } = React.useContext(MotionConfigContext);\n    React.useEffect(() => {\n        if (isStatic)\n            return;\n        const provideTimeSinceStart = ({ timestamp, delta }) => {\n            if (!initialTimestamp.current)\n                initialTimestamp.current = timestamp;\n            callback(timestamp - initialTimestamp.current, delta);\n        };\n        indexLegacy.frame.update(provideTimeSinceStart, true);\n        return () => indexLegacy.cancelFrame(provideTimeSinceStart);\n    }, [callback]);\n}\n\nfunction useTime() {\n    const time = useMotionValue(0);\n    useAnimationFrame((t) => time.set(t));\n    return time;\n}\n\nclass WillChangeMotionValue extends indexLegacy.MotionValue {\n    constructor() {\n        super(...arguments);\n        this.members = [];\n        this.transforms = new Set();\n    }\n    add(name) {\n        let memberName;\n        if (indexLegacy.transformProps.has(name)) {\n            this.transforms.add(name);\n            memberName = \"transform\";\n        }\n        else if (!name.startsWith(\"origin\") &&\n            !indexLegacy.isCSSVariableName(name) &&\n            name !== \"willChange\") {\n            memberName = indexLegacy.camelToDash(name);\n        }\n        if (memberName) {\n            indexLegacy.addUniqueItem(this.members, memberName);\n            this.update();\n        }\n    }\n    remove(name) {\n        if (indexLegacy.transformProps.has(name)) {\n            this.transforms.delete(name);\n            if (!this.transforms.size) {\n                indexLegacy.removeItem(this.members, \"transform\");\n            }\n        }\n        else {\n            indexLegacy.removeItem(this.members, indexLegacy.camelToDash(name));\n        }\n        this.update();\n    }\n    update() {\n        this.set(this.members.length ? this.members.join(\", \") : \"auto\");\n    }\n}\nfunction useWillChange() {\n    return useConstant(() => new WillChangeMotionValue(\"auto\"));\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    !indexLegacy.hasReducedMotionListener.current && indexLegacy.initPrefersReducedMotion();\n    const [shouldReduceMotion] = React.useState(indexLegacy.prefersReducedMotion.current);\n    if (process.env.NODE_ENV !== \"production\") {\n        indexLegacy.warnOnce(shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n    }\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\n\nfunction useReducedMotionConfig() {\n    const reducedMotionPreference = useReducedMotion();\n    const { reducedMotion } = React.useContext(MotionConfigContext);\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 stopAnimation(visualElement) {\n    visualElement.values.forEach((value) => value.stop());\n}\n/**\n * @public\n */\nfunction animationControls() {\n    /**\n     * Track whether the host component has mounted.\n     */\n    let hasMounted = false;\n    /**\n     * A collection of linked component animation controls.\n     */\n    const subscribers = new Set();\n    const controls = {\n        subscribe(visualElement) {\n            subscribers.add(visualElement);\n            return () => void subscribers.delete(visualElement);\n        },\n        start(definition, transitionOverride) {\n            indexLegacy.invariant(hasMounted, \"controls.start() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            const animations = [];\n            subscribers.forEach((visualElement) => {\n                animations.push(animateVisualElement(visualElement, definition, {\n                    transitionOverride,\n                }));\n            });\n            return Promise.all(animations);\n        },\n        set(definition) {\n            indexLegacy.invariant(hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            return subscribers.forEach((visualElement) => {\n                indexLegacy.setValues(visualElement, definition);\n            });\n        },\n        stop() {\n            subscribers.forEach((visualElement) => {\n                stopAnimation(visualElement);\n            });\n        },\n        mount() {\n            hasMounted = true;\n            return () => {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\nfunction useAnimate() {\n    const scope = useConstant(() => ({\n        current: null,\n        animations: [],\n    }));\n    const animate = useConstant(() => indexLegacy.createScopedAnimate(scope));\n    useUnmountEffect(() => {\n        scope.animations.forEach((animation) => animation.stop());\n    });\n    return [scope, animate];\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    const controls = useConstant(animationControls);\n    useIsomorphicLayoutEffect(controls.mount, []);\n    return controls;\n}\nconst 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(...items) {\n    const index = React.useRef(0);\n    const [item, setItem] = React.useState(items[index.current]);\n    const runCycle = React.useCallback((next) => {\n        index.current =\n            typeof next !== \"number\"\n                ? indexLegacy.wrap(0, items.length, index.current + 1)\n                : next;\n        setItem(items[index.current]);\n    }, \n    // The array will change on each call, but by putting items.length at\n    // the front of this array, we guarantee the dependency comparison will match up\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [items.length, ...items]);\n    return [item, runCycle];\n}\n\nfunction useInView(ref, { root, margin, amount, once = false } = {}) {\n    const [isInView, setInView] = React.useState(false);\n    React.useEffect(() => {\n        if (!ref.current || (once && isInView))\n            return;\n        const onEnter = () => {\n            setInView(true);\n            return once ? undefined : () => setInView(false);\n        };\n        const options = {\n            root: (root && root.current) || undefined,\n            margin,\n            amount,\n        };\n        return indexLegacy.inView(ref.current, onEnter, options);\n    }, [root, ref, margin, once, amount]);\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 */\nclass DragControls {\n    constructor() {\n        this.componentControls = new Set();\n    }\n    /**\n     * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.\n     *\n     * @internal\n     */\n    subscribe(controls) {\n        this.componentControls.add(controls);\n        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    start(event, options) {\n        this.componentControls.forEach((controls) => {\n            controls.start(event.nativeEvent || event, options);\n        });\n    }\n}\nconst createDragControls = () => 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\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(() => {\n        const element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\n/**\n * Checks if a component is a `motion` component.\n */\nfunction isMotionComponent(component) {\n    return (component !== null &&\n        typeof component === \"object\" &&\n        motionComponentSymbol in component);\n}\n\n/**\n * Unwraps a `motion` component and returns either a string for `motion.div` or\n * the React component for `motion(Component)`.\n *\n * If the component is not a `motion` component it returns undefined.\n */\nfunction unwrapMotionComponent(component) {\n    if (isMotionComponent(component)) {\n        return component[motionComponentSymbol];\n    }\n    return undefined;\n}\n\nfunction useInstantLayoutTransition() {\n    return startTransition;\n}\nfunction startTransition(callback) {\n    if (!rootProjectionNode.current)\n        return;\n    rootProjectionNode.current.isUpdating = false;\n    rootProjectionNode.current.blockUpdate();\n    callback && callback();\n}\n\nfunction useInstantTransition() {\n    const [forceUpdate, forcedRenderCount] = useForceUpdate();\n    const startInstantLayoutTransition = useInstantLayoutTransition();\n    const unlockOnFrameRef = React.useRef();\n    React.useEffect(() => {\n        /**\n         * Unblock after two animation frames, otherwise this will unblock too soon.\n         */\n        indexLegacy.frame.postRender(() => indexLegacy.frame.postRender(() => {\n            /**\n             * If the callback has been called again after the effect\n             * triggered this 2 frame delay, don't unblock animations. This\n             * prevents the previous effect from unblocking the current\n             * instant transition too soon. This becomes more likely when\n             * used in conjunction with React.startTransition().\n             */\n            if (forcedRenderCount !== unlockOnFrameRef.current)\n                return;\n            indexLegacy.instantAnimationState.current = false;\n        }));\n    }, [forcedRenderCount]);\n    return (callback) => {\n        startInstantLayoutTransition(() => {\n            indexLegacy.instantAnimationState.current = true;\n            forceUpdate();\n            callback();\n            unlockOnFrameRef.current = forcedRenderCount + 1;\n        });\n    };\n}\nfunction disableInstantTransitions() {\n    indexLegacy.instantAnimationState.current = false;\n}\n\nfunction useResetProjection() {\n    const reset = React__namespace.useCallback(() => {\n        const root = rootProjectionNode.current;\n        if (!root)\n            return;\n        root.resetTree();\n    }, []);\n    return reset;\n}\n\nconst appearStoreId = (id, value) => `${id}: ${value}`;\n\nconst appearAnimationStore = new Map();\n\nlet handoffFrameTime;\nfunction handoffOptimizedAppearAnimation(elementId, valueName, \n/**\n * Legacy arguments. This function is inlined as part of SSG so it can be there's\n * a version mismatch between the main included Motion and the inlined script.\n *\n * Remove in early 2024.\n */\n_value, _frame) {\n    const optimisedValueName = indexLegacy.transformProps.has(valueName)\n        ? \"transform\"\n        : valueName;\n    const storeId = appearStoreId(elementId, optimisedValueName);\n    const optimisedAnimation = appearAnimationStore.get(storeId);\n    if (!optimisedAnimation) {\n        return null;\n    }\n    const { animation, startTime } = optimisedAnimation;\n    const cancelAnimation = () => {\n        appearAnimationStore.delete(storeId);\n        try {\n            animation.cancel();\n        }\n        catch (error) { }\n    };\n    /**\n     * If the startTime is null, this animation is the Paint Ready detection animation\n     * and we can cancel it immediately without handoff.\n     *\n     * Or if we've already handed off the animation then we're now interrupting it.\n     * In which case we need to cancel it.\n     */\n    if (startTime === null || window.HandoffComplete) {\n        cancelAnimation();\n        return null;\n    }\n    else {\n        /**\n         * Otherwise we're handing off this animation to the main thread.\n         *\n         * Record the time of the first handoff. We call performance.now() once\n         * here and once in startOptimisedAnimation to ensure we're getting\n         * close to a frame-locked time. This keeps all animations in sync.\n         */\n        if (handoffFrameTime === undefined) {\n            handoffFrameTime = performance.now();\n        }\n        /**\n         * We use main thread timings vs those returned by Animation.currentTime as it\n         * can be the case, particularly in Firefox, that currentTime doesn't return\n         * an updated value for several frames, even as the animation plays smoothly via\n         * the GPU.\n         */\n        return handoffFrameTime - startTime || 0;\n    }\n}\n\n/**\n * A single time to use across all animations to manually set startTime\n * and ensure they're all in sync.\n */\nlet startFrameTime;\n/**\n * A dummy animation to detect when Chrome is ready to start\n * painting the page and hold off from triggering the real animation\n * until then. We only need one animation to detect paint ready.\n *\n * https://bugs.chromium.org/p/chromium/issues/detail?id=1406850\n */\nlet readyAnimation;\nfunction startOptimizedAppearAnimation(element, name, keyframes, options, onReady) {\n    // Prevent optimised appear animations if Motion has already started animating.\n    if (window.HandoffComplete) {\n        window.HandoffAppearAnimations = undefined;\n        return;\n    }\n    const id = element.dataset[indexLegacy.optimizedAppearDataId];\n    if (!id)\n        return;\n    window.HandoffAppearAnimations = handoffOptimizedAppearAnimation;\n    const storeId = appearStoreId(id, name);\n    if (!readyAnimation) {\n        readyAnimation = indexLegacy.animateStyle(element, name, [keyframes[0], keyframes[0]], \n        /**\n         * 10 secs is basically just a super-safe duration to give Chrome\n         * long enough to get the animation ready.\n         */\n        { duration: 10000, ease: \"linear\" });\n        appearAnimationStore.set(storeId, {\n            animation: readyAnimation,\n            startTime: null,\n        });\n    }\n    const startAnimation = () => {\n        readyAnimation.cancel();\n        const appearAnimation = indexLegacy.animateStyle(element, name, keyframes, options);\n        /**\n         * Record the time of the first started animation. We call performance.now() once\n         * here and once in handoff to ensure we're getting\n         * close to a frame-locked time. This keeps all animations in sync.\n         */\n        if (startFrameTime === undefined) {\n            startFrameTime = performance.now();\n        }\n        appearAnimation.startTime = startFrameTime;\n        appearAnimationStore.set(storeId, {\n            animation: appearAnimation,\n            startTime: startFrameTime,\n        });\n        if (onReady)\n            onReady(appearAnimation);\n    };\n    if (readyAnimation.ready) {\n        readyAnimation.ready.then(startAnimation).catch(indexLegacy.noop);\n    }\n    else {\n        startAnimation();\n    }\n}\n\nconst createObject = () => ({});\nclass StateVisualElement extends indexLegacy.VisualElement {\n    build() { }\n    measureInstanceViewportBox() {\n        return indexLegacy.createBox();\n    }\n    resetTransform() { }\n    restoreTransform() { }\n    removeValueFromRenderState() { }\n    renderInstance() { }\n    scrapeMotionValuesFromProps() {\n        return createObject();\n    }\n    getBaseTargetFromProps() {\n        return undefined;\n    }\n    readValueFromInstance(_state, key, options) {\n        return options.initialState[key] || 0;\n    }\n    sortInstanceNodePosition() {\n        return 0;\n    }\n    makeTargetAnimatableFromInstance({ transition, transitionEnd, ...target }) {\n        const origin = indexLegacy.getOrigin(target, transition || {}, this);\n        indexLegacy.checkTargetForNewValues(this, target, origin);\n        return { transition, transitionEnd, ...target };\n    }\n}\nconst 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    const [animationState, setAnimationState] = React.useState(initialState);\n    const visualState = useVisualState({}, false);\n    const element = useConstant(() => {\n        return new StateVisualElement({ props: {}, visualState, presenceContext: null }, { initialState });\n    });\n    React.useEffect(() => {\n        element.mount({});\n        return () => element.unmount();\n    }, [element]);\n    React.useEffect(() => {\n        element.update({\n            onUpdate: (v) => {\n                setAnimationState({ ...v });\n            },\n        }, null);\n    }, [setAnimationState, element]);\n    const startAnimation = useConstant(() => (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.\nconst maxScale = 100000;\nconst invertScale = (scale) => scale > 0.001 ? 1 / scale : maxScale;\nlet 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    let parentScaleX = useMotionValue(1);\n    let parentScaleY = useMotionValue(1);\n    const { visualElement } = React.useContext(MotionContext);\n    indexLegacy.invariant(!!(scale || visualElement), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n    indexLegacy.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    const scaleX = useTransform(parentScaleX, invertScale);\n    const scaleY = useTransform(parentScaleY, invertScale);\n    return { scaleX, scaleY };\n}\n\nlet id = 0;\nconst AnimateSharedLayout = ({ children }) => {\n    React__namespace.useEffect(() => {\n        indexLegacy.invariant(false, \"AnimateSharedLayout is deprecated: https://www.framer.com/docs/guide-upgrade/##shared-layout-animations\");\n    }, []);\n    return (React__namespace.createElement(LayoutGroup, { id: useConstant(() => `asl-${id++}`) }, children));\n};\n\nexports.MotionGlobalConfig = indexLegacy.MotionGlobalConfig;\nexports.MotionValue = indexLegacy.MotionValue;\nexports.VisualElement = indexLegacy.VisualElement;\nexports.addScaleCorrector = indexLegacy.addScaleCorrector;\nexports.animate = indexLegacy.animate;\nexports.animateValue = indexLegacy.animateValue;\nexports.anticipate = indexLegacy.anticipate;\nexports.backIn = indexLegacy.backIn;\nexports.backInOut = indexLegacy.backInOut;\nexports.backOut = indexLegacy.backOut;\nexports.buildTransform = indexLegacy.buildTransform;\nexports.cancelFrame = indexLegacy.cancelFrame;\nexports.cancelSync = indexLegacy.cancelSync;\nexports.checkTargetForNewValues = indexLegacy.checkTargetForNewValues;\nexports.circIn = indexLegacy.circIn;\nexports.circInOut = indexLegacy.circInOut;\nexports.circOut = indexLegacy.circOut;\nexports.clamp = indexLegacy.clamp;\nexports.color = indexLegacy.color;\nexports.complex = indexLegacy.complex;\nexports.createBox = indexLegacy.createBox;\nexports.createScopedAnimate = indexLegacy.createScopedAnimate;\nexports.cubicBezier = indexLegacy.cubicBezier;\nexports.delay = indexLegacy.delay;\nexports.distance = indexLegacy.distance;\nexports.distance2D = indexLegacy.distance2D;\nexports.easeIn = indexLegacy.easeIn;\nexports.easeInOut = indexLegacy.easeInOut;\nexports.easeOut = indexLegacy.easeOut;\nexports.frame = indexLegacy.frame;\nexports.frameData = indexLegacy.frameData;\nexports.inView = indexLegacy.inView;\nexports.interpolate = indexLegacy.interpolate;\nObject.defineProperty(exports, 'invariant', {\n    enumerable: true,\n    get: function () { return indexLegacy.invariant; }\n});\nexports.isBrowser = indexLegacy.isBrowser;\nexports.isMotionValue = indexLegacy.isMotionValue;\nexports.mirrorEasing = indexLegacy.mirrorEasing;\nexports.mix = indexLegacy.mix;\nexports.motionValue = indexLegacy.motionValue;\nexports.optimizedAppearDataAttribute = indexLegacy.optimizedAppearDataAttribute;\nexports.pipe = indexLegacy.pipe;\nexports.progress = indexLegacy.progress;\nexports.px = indexLegacy.px;\nexports.reverseEasing = indexLegacy.reverseEasing;\nexports.scroll = indexLegacy.scroll;\nexports.scrollInfo = indexLegacy.scrollInfo;\nexports.spring = indexLegacy.spring;\nexports.stagger = indexLegacy.stagger;\nexports.steps = indexLegacy.steps;\nexports.sync = indexLegacy.sync;\nexports.transform = indexLegacy.transform;\nexports.visualElementStore = indexLegacy.visualElementStore;\nObject.defineProperty(exports, 'warning', {\n    enumerable: true,\n    get: function () { return indexLegacy.warning; }\n});\nexports.wrap = indexLegacy.wrap;\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.PresenceContext = PresenceContext;\nexports.Reorder = Reorder;\nexports.SwitchLayoutGroupContext = SwitchLayoutGroupContext;\nexports.addPointerEvent = addPointerEvent;\nexports.addPointerInfo = addPointerInfo;\nexports.animateVisualElement = animateVisualElement;\nexports.animationControls = animationControls;\nexports.animations = animations;\nexports.calcLength = calcLength;\nexports.createDomMotionComponent = createDomMotionComponent;\nexports.createMotionComponent = createMotionComponent;\nexports.disableInstantTransitions = disableInstantTransitions;\nexports.domAnimation = domAnimation;\nexports.domMax = domMax;\nexports.filterProps = filterProps;\nexports.isDragActive = isDragActive;\nexports.isMotionComponent = isMotionComponent;\nexports.isValidMotionProp = isValidMotionProp;\nexports.m = m;\nexports.makeUseVisualState = makeUseVisualState;\nexports.motion = motion;\nexports.resolveMotionValue = resolveMotionValue;\nexports.startOptimizedAppearAnimation = startOptimizedAppearAnimation;\nexports.unwrapMotionComponent = unwrapMotionComponent;\nexports.useAnimate = useAnimate;\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.useMotionValueEvent = useMotionValueEvent;\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.useWillChange = useWillChange;\n"],"names":["React","indexLegacy","_interopDefaultLegacy","e","_interopNamespace","__esModule","n","Object","create","keys","forEach","k","d","getOwnPropertyDescriptor","defineProperty","get","enumerable","freeze","React__namespace","React__default","MotionConfigContext","createContext","transformPagePoint","p","isStatic","reducedMotion","MotionContext","PresenceContext","useIsomorphicLayoutEffect","isBrowser","useLayoutEffect","useEffect","LazyContext","strict","useCreateMotionContext","props","initial","animate","context","isControllingVariants","isVariantLabel","undefined","inherit","getCurrentTreeVariants","useContext","useMemo","variantLabelsAsDependency","prop","Array","isArray","join","loadFeatures","features","key","featureDefinitions","LayoutGroupContext","SwitchLayoutGroupContext","motionComponentSymbol","Symbol","for","createMotionComponent","preloadedFeatures","createVisualElement","useRender","useVisualState","Component","ForwardRefComponent","forwardRef","externalRef","MeasureLayout","configAndProps","layoutId","useLayoutId","visualState","visualElement","parent","lazyContext","presenceContext","reducedMotionConfig","visualElementRef","useRef","renderer","current","blockInitialAnimation","useInsertionEffect","update","wantsHandoff","Boolean","optimizedAppearDataAttribute","window","HandoffComplete","render","animationState","animateChanges","updateFeatures","useVisualElement","initialLayoutGroupConfig","isStrict","createElement","Provider","value","useCallback","instance","mount","unmount","isRefObject","useMotionRef","layoutGroupId","id","createMotionProxy","createConfig","custom","customMotionComponentConfig","Proxy","componentCache","Map","_target","has","set","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","createHtmlRenderState","style","transform","transformOrigin","vars","copyRawValuesOnly","target","source","isMotionValue","isForcedMotionValue","useStyle","assign","transformTemplate","state","buildHTMLStyles","enableHardwareAcceleration","useInitialMotionValues","transformValues","useHTMLProps","htmlProps","drag","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","tabIndex","onTap","onTapStart","whileTap","validMotionProps","Set","isValidMotionProp","startsWith","shouldForward","loadExternalIsValidProp","isValidProp","_a","filterProps","isDom","forwardMotionProps","filteredProps","values","createSvgRenderState","attrs","useSVGProps","_isStatic","visualProps","buildSVGAttrs","isSVGTag","rawStyles","createUseRender","ref","latestValues","elementProps","children","renderedChildren","useConstant","init","resolveMotionValue","unwrappedValue","isCustomValue","toValue","makeUseVisualState","config","make","scrapeMotionValuesFromProps","createRenderState","onMount","makeLatestValues","renderState","makeState","scrapeMotionValues","motionValues","isVariantNode","isInitialAnimationBlocked","variantToSet","isAnimationControls","definition","resolved","resolveVariantFromProps","transitionEnd","transition","valueTarget","length","svgMotionConfig","frame","read","dimensions","getBBox","getBoundingClientRect","x","y","width","height","tagName","renderSVG","htmlMotionConfig","scrapeMotionValuesFromProps$1","createDomMotionConfig","addDomEvent","eventName","handler","options","passive","addEventListener","removeEventListener","isPrimaryPointer","event","pointerType","button","isPrimary","extractEventInfo","pointType","point","addPointerInfo","addPointerEvent","createLock","name","lock","openLock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal","openVertical","isDragActive","openGestureLock","Feature","constructor","node","this","isMounted","addHoverEvent","isActive","callbackName","info","getProps","whileHover","setActive","isNodeOrChild","child","parentElement","fireSyntheticPointerEvent","syntheticPointerEvent","PointerEvent","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","callback","fireAllObserverCallbacks","entries","observeIntersection","element","rootInteresectionObserver","root","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","delete","unobserve","thresholdNames","some","all","gestureAnimations","inView","super","arguments","hasEnteredView","isInView","startObserver","viewport","margin","rootMargin","amount","once","threshold","isIntersecting","onViewportEnter","onViewportLeave","prevProps","prevViewport","hasViewportOptionChanged","tap","removeStartListeners","noop","removeEndListeners","removeAccessibleListeners","startPointerPress","startEvent","startInfo","isPressing","removePointerUpListener","endEvent","endInfo","checkPressEnd","onTapCancel","globalTapTarget","removePointerCancelListener","cancelEvent","cancelInfo","cancelPress","pipe","startPress","startAccessiblePress","removeKeydownListener","keydownEvent","keyupEvent","removeBlurListener","removePointerListener","removeFocusListener","focus","onFocus","isFocusVisible","matches","onBlur","hover","shallowCompare","next","prev","prevLength","i","animateVariant","variant","resolveVariant","getDefaultTransition","transitionOverride","getAnimation","Promise","animateTarget","resolve","getChildAnimations","variantChildren","size","forwardDelay","delayChildren","staggerChildren","staggerDirection","animations","maxStaggerDuration","generateStaggerDuration","from","sort","sortByTreeOrder","notify","push","delay","then","animateChildren","when","first","last","a","b","sortNodePosition","animateVisualElement","animation","map","resolvedDefinition","reversePriorityOrder","variantPriorityOrder","reverse","numAnimationTypes","createAnimationState","animateList","createTypeState","whileInView","whileDrag","whileFocus","exit","isInitialRender","buildResolvedTypeValues","acc","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","type","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","protectedKeys","prevProp","shouldAnimateType","checkVariantsDidChange","handledRemovedValues","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","needsAnimating","hasOwnProperty","valueHasChanged","isKeyframesTarget","add","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setAnimateFunction","makeAnimator","getState","id$2","updateAnimationControlsSubscription","subscribe","prevAnimate","isPresent","onExitComplete","prevIsPresent","prevPresenceContext","exitAnimation","register","PanSession","handlers","contextWindow","dragSnapToOrigin","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance2D","offset","timestamp","frameData","onStart","onMove","handlePointerMove","transformPoint","handlePointerUp","end","onEnd","onSessionEnd","resumeAnimation","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","cancelFrame","subtractPoint","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","timestampedPoint","lastPoint","secondsToMilliseconds","time","millisecondsToSeconds","currentVelocity","calcLength","axis","max","min","isNear","maxDistance","Math","abs","calcAxisDelta","origin","originPoint","mix","scale","isNaN","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","eachAxis","getContextWindow","ownerDocument","defaultView","elementDragControls","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","createBox","start","originEvent","snapToCursor","panSession","pauseAnimation","stopAnimation","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","getAxisMotionValue","percent","measuredAxis","layoutBox","parseFloat","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","stop","getAnimationState","play","getTransformPagePoint","cancel","startAnimation","onDragEnd","_point","shouldDrag","axisValue","applyConstraints","dragConstraints","measure","prevConstraints","resolveRefConstraints","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","invariant","constraintsBox","measurePageBox","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","convertBoundingBoxToBox","dragMomentum","dragTransition","onDragTransitionEnd","momentumAnimations","bounceStiffness","bounceDamping","inertia","timeConstant","restDelta","restSpeed","startAxisValueAnimation","animateMotionValue","pause","dragKey","toUpperCase","externalMotionValue","getValue","scalePositionWithinConstraints","boxProgress","latest","sourceLength","targetLength","progress","clamp","calcOrigin","updateScroll","updateLayout","addListeners","stopPointerListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","stopLayoutUpdateListener","hasLayoutChanged","motionValue","asyncHandler","borders","numBorders","asNumber","isPx","px","getRadius","radiusName","borderRadius","easeCrossfadeIn","compress","circOut","easeCrossfadeOut","easing","copyAxisInto","originAxis","copyBoxInto","box","originBox","removePointDelta","boxScale","scalePoint","removeAxisTransforms","transforms","scaleKey","originKey","sourceAxis","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEqualsRounded","round","aspectRatio","NodeStack","members","addUniqueItem","scheduleRender","remove","removeItem","prevLead","lead","promote","relegate","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","buildProjectionTransform","treeScale","latestTransform","xTranslate","yTranslate","rotate","rotateX","rotateY","elementScaleX","elementScaleY","compareByDepth","depth","FlatTree","isDirty","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","transformAxes","hiddenVisibility","visibility","id$1","projectionFrameData","totalNodes","resolvedTargetDeltas","recalculatedProjection","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","animationId","isTreeAnimating","isProjectionDirty","isSharedProjectionDirty","isTransformDirty","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","hasTreeAnimated","updateScheduled","projectionUpdateScheduled","checkUpdateFailed","clearAllSnapshots","updateProjection","data","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","cleanDirtyNodes","MotionDebug","record","hasProjected","isVisible","animationProgress","sharedNodes","path","SubscriptionManager","notifyListeners","args","subscriptionManager","hasListeners","isSVGElement","cancelDelay","resizeUnblockUpdate","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","layoutRoot","currentAnimation","setAnimationOrigin","animationOptions","getValueTransition","onPlay","onComplete","shouldReduceMotion","isLead","willUpdate","stack","getStack","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","getTransformTemplate","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","clearIsLayoutDirty","resetTransformStyle","notifyLayoutUpdate","now","performance","isProcessing","steps","process","preRender","didUpdate","queueMicrotask","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","scheduleCheckAfterUnmount","postRender","alwaysMeasureLayout","prevLayout","layoutCorrected","projectionDelta","phase","needsMeasurement","layoutScroll","scroll","isRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","hasTransform","removeTransform","pageBox","removeElementScroll","roundAxis","measuredBox","measureViewportBox","translateAxis","boxWithoutScroll","rootScroll","applyTransform","transformOnly","withTransforms","transformBox","boxWithoutTransform","hasScale","setTargetDelta","targetDelta","setOptions","forceRelativeParentToResolveTarget","relativeParent","resolvedRelativeTargetAt","forceRecalculation","getLead","isShared","attemptToResolveRelativeTarget","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","applyBoxDelta","has2DTranslate","isProjecting","canSkip","pendingAnimation","prevTreeScaleX","prevTreeScaleY","applyTreeDeltas","projectionTransform","createDelta","projectionDeltaWithTransform","prevProjectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","prevRelativeTarget","mixTargetDelta","output","to","mixAxisDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","animateSingleValue","onUpdate","completeAnimation","applyTransformsToTarget","shouldAnimatePositionOnly","animationType","xLength","yLength","initialPromotionConfig","shouldPreserveFollowOpacity","getPrevLead","hasRotate","rotateZ","resetValues","setStaticValue","getProjectionStyles","styleProp","_b","styles","pointerEvents","emptyStyles","valuesToRender","scaleCorrectors","correct","applyTo","corrected","num","resetTree","clear","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","duration","ease","userAgentContains","string","navigator","userAgent","toLowerCase","roundPoint","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","rootProjectionNode","HTMLProjectionNode","documentNode","getComputedStyle","position","nodeGroup","subscriptions","dirtyAll","unsubscribe","dirty","pixelsToPercent","pixels","correctBorderRadius","correctBoxShadow","original","shadow","complex","parse","template","createTransformer","xScale","yScale","averageScale","usePresence","useId","MeasureLayoutWithContext","componentDidMount","layoutGroup","switchLayoutGroup","addScaleCorrector","defaultScaleCorrectors","group","safeToRemove","getSnapshotBeforeUpdate","layoutDependency","componentDidUpdate","componentWillUnmount","promoteContext","deregister","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","pan","removePointerDownListener","onPointerDown","pointerDownEvent","session","createPanHandlers","onPanSessionStart","onPanStart","onPan","onPanEnd","removeGroupControls","controls","dragControls","ProjectionNode","createDomVisualElement","SVGVisualElement","HTMLVisualElement","motion","m","useIsMounted","useForceUpdate","forcedRenderCount","setForcedRenderCount","useState","forceRender","PopChildMeasure","childRef","sizeRef","offsetHeight","offsetWidth","offsetTop","offsetLeft","PopChild","dataset","motionPopId","head","appendChild","sheet","insertRule","removeChild","cloneElement","PresenceChild","presenceAffectsLayout","mode","presenceChildren","newChildrenMap","childId","isComplete","_","useUnmountEffect","getChildKey","isLazyBundle","DeprecatedLayoutGroupContext","shouldInheritGroup","LayoutGroup","layoutGroupContext","deprecatedLayoutGroupContext","upstreamId","shouldInheritId","memoizedContext","ReorderContext","Group","as","onReorder","order","isReordering","registerItem","idx","compareMin","updateOrder","item","newOrder","index","nextOffset","nextItem","nextLayout","nextItemCenter","moveItem","checkReorder","filter","ignoreStrict","useMotionValue","setLatest","on","useCombineMotionValues","combineValues","updateValue","scheduleUpdate","v","useTransform","input","inputRangeOrTransformer","outputRange","compute","collectMotionValues","useComputed","transformer","useListTransform","numValues","useDefaultMotionValue","defaultValue","Item","zIndex","latestX","latestY","gesturePoint","onLayoutMeasure","measured","Reorder","domAnimation","domMax","useMotionValueEvent","refWarning","warning","createScrollMotionValues","scrollX","scrollY","scrollXProgress","scrollYProgress","useScroll","container","layoutEffect","scrollInfo","useAnimationFrame","initialTimestamp","provideTimeSinceStart","WillChangeMotionValue","MotionValue","memberName","transformProps","isCSSVariableName","camelToDash","useReducedMotion","hasReducedMotionListener","initPrefersReducedMotion","prefersReducedMotion","animationControls","hasMounted","subscribers","setValues","useAnimationControls","useAnimation","DragControls","componentControls","nativeEvent","createDragControls","isMotionComponent","component","useInstantLayoutTransition","startTransition","appearStoreId","appearAnimationStore","handoffFrameTime","startFrameTime","readyAnimation","handoffOptimizedAppearAnimation","elementId","valueName","_value","_frame","optimisedValueName","storeId","optimisedAnimation","startTime","error","cancelAnimation","createObject","StateVisualElement","VisualElement","build","measureInstanceViewportBox","restoreTransform","removeValueFromRenderState","renderInstance","getBaseTargetFromProps","readValueFromInstance","_state","initialState","sortInstanceNodePosition","makeTargetAnimatableFromInstance","getOrigin","checkTargetForNewValues","invertScale","hasWarned","MotionGlobalConfig","animateValue","anticipate","backIn","backInOut","backOut","buildTransform","cancelSync","circIn","circInOut","color","createScopedAnimate","cubicBezier","distance","easeIn","easeInOut","easeOut","interpolate","mirrorEasing","reverseEasing","spring","stagger","sync","visualElementStore","wrap","exports","exitBeforeEnter","filteredChildren","filtered","Children","isValidElement","onlyElements","childrenToRender","exitingChildren","presentChildren","allChildren","updateChildLookup","Fragment","presentKeys","targetKeys","numPresent","insertionIndex","exitingComponent","onExit","leftOverKeys","childKey","leftOverKey","presentChild","presentChildKey","splice","setIsLoaded","loadedRenderer","loadedFeatures"],"sourceRoot":""}