{"version":3,"file":"5677-b3df6efc295b9cdfdc76.js","mappings":"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","sources":["webpack://tipton/./node_modules/hey-listen/dist/hey-listen.es.js","webpack://tipton/./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/node/state.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/use-features.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/use-reduced-motion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/projection/node/id.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/VisualElementHandler.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/index.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/features/use-projection.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/motion-minimal.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/render/utils/variants.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/process.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack://tipton/./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/numbers/index.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/numbers/units.mjs","webpack://tipton/./node_modules/style-value-types/dist/es/utils.mjs","webpack://tipton/./node_modules/tslib/tslib.es6.mjs"],"sourcesContent":["var warning = function () { };\r\nvar invariant = function () { };\r\nif (process.env.NODE_ENV !== 'production') {\r\n    warning = function (check, message) {\r\n        if (!check && typeof console !== 'undefined') {\r\n            console.warn(message);\r\n        }\r\n    };\r\n    invariant = function (check, message) {\r\n        if (!check) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n}\n\nexport { invariant, warning };\n","function isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nexport { isAnimationControls };\n","var isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","import { createContext } from 'react';\n\nvar LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","import { createContext } from 'react';\n\nvar LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar MotionConfigContext = createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","import { createContext } from 'react';\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\n","var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n","import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nexport { globalProjectionState };\n","var scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { env } from '../../utils/process.mjs';\nimport { featureDefinitions } from './definitions.mjs';\nimport { invariant } from 'hey-listen';\nimport { LazyContext } from '../../context/LazyContext.mjs';\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = useContext(LazyContext);\n    if (!visualElement)\n        return null;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (env !== \"production\" && preloadedFeatures && lazyContext.strict) {\n        invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React.createElement(Component, __assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\nexport { useFeatures };\n","import { createContext, useContext } from 'react';\n\nvar MotionContext = createContext({});\nfunction useVisualElementContext() {\n    return useContext(MotionContext).visualElement;\n}\n\nexport { MotionContext, useVisualElementContext };\n","import { __read } from 'tslib';\nimport { useState, useContext } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { isBrowser } from './is-browser.mjs';\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = __read(useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nexport { useReducedMotion, useReducedMotionConfig };\n","import { useContext, useRef, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useVisualElementContext } from '../../context/MotionContext/index.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { useReducedMotionConfig } from '../../utils/use-reduced-motion.mjs';\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\n    var visualElementRef = useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nexport { useVisualElement };\n","import { useMemo, useContext } from 'react';\nimport { MotionContext } from './index.mjs';\nimport { getCurrentTreeVariants } from './utils.mjs';\n\nfunction useCreateMotionContext(props) {\n    var _a = getCurrentTreeVariants(props, useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { useConstant } from '../../utils/use-constant.mjs';\nimport { globalProjectionState } from './state.mjs';\n\nvar id = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id++;\n        }\n    });\n}\n\nexport { useProjectionId };\n","import { __extends } from 'tslib';\nimport React__default from 'react';\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    __extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default.Component));\n\nexport { VisualElementHandler };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { forwardRef, useContext } from 'react';\nimport { useFeatures } from './features/use-features.mjs';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { MotionContext } from '../context/MotionContext/index.mjs';\nimport { useVisualElement } from './utils/use-visual-element.mjs';\nimport { useMotionRef } from './utils/use-motion-ref.mjs';\nimport { useCreateMotionContext } from '../context/MotionContext/create.mjs';\nimport { loadFeatures, featureDefinitions } from './features/definitions.mjs';\nimport { isBrowser } from '../utils/is-browser.mjs';\nimport { useProjectionId } from '../projection/node/id.mjs';\nimport { LayoutGroupContext } from '../context/LayoutGroupContext.mjs';\nimport { useProjection } from './features/use-projection.mjs';\nimport { VisualElementHandler } from './utils/VisualElementHandler.mjs';\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = __assign(__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, __assign(__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React.createElement(VisualElementHandler, { visualElement: context.visualElement, props: __assign(__assign({}, config), props) },\n            features,\n            React.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\n\nexport { createMotionComponent };\n","import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/variants.mjs';\n\nfunction getCurrentTreeVariants(props, context) {\n    if (checkIfControllingVariants(props)) {\n        var initial = props.initial, animate = props.animate;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nexport { getCurrentTreeVariants };\n","import { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { useContext } from 'react';\nimport { SwitchLayoutGroupContext } from '../../context/SwitchLayoutGroupContext.mjs';\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.scheduleRender(); },\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nexport { useProjection };\n","import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\nexport { useMotionRef };\n","var createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\n\nexport { createHtmlRenderState };\n","import { __assign } from 'tslib';\nimport { useMemo } from 'react';\nimport { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (var key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues(_a, visualState, isStatic) {\n    var transformTemplate = _a.transformTemplate;\n    return useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return __assign(__assign({}, vars), style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    var styleProp = props.style || {};\n    var style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    if (props.transformValues) {\n        style = props.transformValues(style);\n    }\n    return style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    var htmlProps = {};\n    var style = useStyle(props, visualState, isStatic);\n    if (Boolean(props.drag) && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps, useStyle };\n","import { __assign } from 'tslib';\nimport { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';\n\nvar createSvgRenderState = function () { return (__assign(__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nexport { createSvgRenderState };\n","import { __assign } from 'tslib';\nimport { useMemo } from 'react';\nimport { copyRawValuesOnly } from '../html/use-props.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return __assign(__assign({}, state.attrs), { style: __assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = __assign(__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nexport { useSVGProps };\n","import { __assign } from 'tslib';\nimport { createElement } from 'react';\nimport { useHTMLProps } from '../html/use-props.mjs';\nimport { filterProps } from './utils/filter-props.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\nimport { useSVGProps } from '../svg/use-props.mjs';\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = __assign(__assign(__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\n        return createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nexport { createUseRender };\n","import { __rest } from 'tslib';\nimport { useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, resolveVariantFromProps } from '../../render/utils/variants.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { MotionContext } from '../../context/MotionContext/index.mjs';\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) {\n    return function (props, isStatic) {\n        var context = useContext(MotionContext);\n        var presenceContext = useContext(PresenceContext);\n        return isStatic\n            ? makeState(config, props, context, presenceContext)\n            : useConstant(function () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = __rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\n","import { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\n            try {\n                renderState.dimensions =\n                    typeof instance.getBBox ===\n                        \"function\"\n                        ? instance.getBBox()\n                        : instance.getBoundingClientRect();\n            }\n            catch (e) {\n                // Most likely trying to measure an unrendered element under Firefox\n                renderState.dimensions = {\n                    x: 0,\n                    y: 0,\n                    width: 0,\n                    height: 0,\n                };\n            }\n            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nexport { svgMotionConfig };\n","import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","import { createMotionProxy } from './motion-proxy.mjs';\nimport { createDomMotionConfig } from './utils/create-config.mjs';\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nexport { m };\n","import { createMotionComponent } from '../../motion/index.mjs';\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig) {\n        if (customMotionComponentConfig === void 0) { customMotionComponentConfig = {}; }\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    var componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: function (_target, key) {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\nexport { createMotionProxy };\n","import { __assign } from 'tslib';\nimport { isSVGComponent } from './is-svg-component.mjs';\nimport { createUseRender } from '../use-render.mjs';\nimport { svgMotionConfig } from '../../svg/config-motion.mjs';\nimport { htmlMotionConfig } from '../../html/config-motion.mjs';\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return __assign(__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexport { createDomMotionConfig };\n","var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nexport { camelToDash };\n","/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nexport { isValidMotionProp };\n","import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    var filteredProps = {};\n    for (var key in props) {\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps, loadExternalIsValidProp };\n","/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable(key) {\n    return key.startsWith(\"--\");\n}\n\nexport { isCSSVariable };\n","/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\n","import { __assign } from 'tslib';\nimport { number } from 'style-value-types';\n\nvar int = __assign(__assign({}, number), { transform: Math.round });\n\nexport { int };\n","import { px, degrees, scale, alpha, progressPercentage } from 'style-value-types';\nimport { int } from './type-int.mjs';\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\n","import { sortTransformProps } from './transform.mjs';\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\nexport { buildTransform, buildTransformOrigin };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","import { buildTransform, buildTransformOrigin } from './build-transform.mjs';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.mjs';\nimport { isTransformProp, isTransformOriginProp } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nexport { buildHTMLStyles };\n","function renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n","import { px } from 'style-value-types';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    var pathLength = px.transform(length);\n    var pathSpacing = px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = __rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nexport { camelCaseAttributes };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nexport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };\n","var isBrowser = typeof document !== \"undefined\";\n\nexport { isBrowser };\n","function isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n","/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nexport { env };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nvar useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n","var isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nexport { isMotionValue };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n","import { clamp } from '../utils.mjs';\n\nconst number = {\n    test: (v) => typeof v === 'number',\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = Object.assign(Object.assign({}, number), { transform: clamp(0, 1) });\nconst scale = Object.assign(Object.assign({}, number), { default: 1 });\n\nexport { alpha, number, scale };\n","import { isString } from '../utils.mjs';\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(' ').length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType('deg');\nconst percent = createUnitType('%');\nconst px = createUnitType('px');\nconst vh = createUnitType('vh');\nconst vw = createUnitType('vw');\nconst progressPercentage = Object.assign(Object.assign({}, percent), { parse: (v) => percent.parse(v) / 100, transform: (v) => percent.transform(v * 100) });\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","const clamp = (min, max) => (v) => Math.max(Math.min(v, max), min);\nconst sanitize = (v) => (v % 1 ? Number(v.toFixed(5)) : v);\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nexport { clamp, colorRegex, floatRegex, isString, sanitize, singleColorRegex };\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n  return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  function next() {\n    while (env.stack.length) {\n      var rec = env.stack.pop();\n      try {\n        var result = rec.dispose && rec.dispose.call(rec.value);\n        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n      }\n      catch (e) {\n          fail(e);\n      }\n    }\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n};\n"],"names":["warning","invariant","isAnimationControls","v","start","isKeyframesTarget","Array","isArray","LayoutGroupContext","createContext","LazyContext","strict","MotionConfigContext","transformPagePoint","p","isStatic","reducedMotion","PresenceContext","SwitchLayoutGroupContext","createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","inView","loadFeatures","features","key","projectionNodeConstructor","Component","isForcedMotionValue","_a","layout","layoutId","undefined","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","scaleCorrectors","addScaleCorrector","correctors","Object","assign","featureNames","keys","numFeatures","length","MotionContext","prefersReducedMotion","current","hasDetected","useVisualElement","visualState","createVisualElement","reducedMotionPreference","lazyContext","useContext","parent","visualElement","presenceContext","shouldReduceMotion","window","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","useState","visualElementRef","useRef","renderer","presenceId","id","blockInitialAnimation","initial","syncRender","useEffect","animationState","animateChanges","notifyUnmount","variantLabelsAsDependency","prop","join","VisualElementHandler","_super","apply","this","arguments","prototype","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","setProps","render","children","createMotionComponent","preloadedFeatures","useRender","useVisualState","forwardRef","externalRef","_b","layoutGroupId","L","useLayoutId","config","context","animate","inherit","getCurrentTreeVariants","useMemo","useCreateMotionContext","projectionId","ProjectionNodeConstructor","dragConstraints","layoutScroll","initialPromotionConfig","projection","getLatestValues","setOptions","alwaysMeasureLayout","Boolean","scheduleRender","animationType","useProjection","i","name_1","push","useFeatures","Provider","value","useCallback","instance","mount","call","unmount","useMotionRef","createHtmlRenderState","style","transform","transformKeys","transformOrigin","vars","copyRawValuesOnly","target","source","useHTMLProps","htmlProps","transformTemplate","state","enableHardwareAcceleration","useInitialMotionValues","transformValues","useStyle","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","concat","createSvgRenderState","attrs","useSVGProps","visualProps","rawStyles","createUseRender","forwardMotionProps","ref","latestValues","filteredProps","elementProps","createElement","makeState","scrapeMotionValuesFromProps","createRenderState","onMount","makeLatestValues","renderState","makeUseVisualState","scrapeMotionValues","values","motionValues","isControllingVariants","isVariantNode","initialAnimationIsBlocked","variantToSet","forEach","definition","resolved","transitionEnd","transition","valueTarget","svgMotionConfig","dimensions","getBBox","getBoundingClientRect","e","x","y","width","height","htmlMotionConfig","m","custom","customMotionComponentConfig","baseConfig","createConfig","Proxy","componentCache","Map","get","_target","has","set","createMotionProxy","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","validMotionProps","Set","isValidMotionProp","shouldForward","loadExternalIsValidProp","isValidProp","startsWith","require","default","filterProps","isDom","isCSSVariable","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","Math","round","numberValueTypes","borderWidth","px","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","size","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scale","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","z","perspective","transformPerspective","opacity","originX","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","translateAlias","getValueAsType","type","buildHTMLStyles","options","hasTransform","hasTransformOrigin","transformIsNone","valueType","number","valueAsType","transformIsDefault","_c","_d","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","trim","buildTransform","buildTransformOrigin","renderHTML","element","styleProp","getProjectionStyles","setProperty","newValues","transformAxes","transformProps","sortTransformProps","a","b","operationKey","axesKey","transformPropSet","isTransformProp","transformOriginProps","isTransformOriginProp","calcOrigin","origin","offset","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","latest","pxOriginX","pxOriginY","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","camelCaseAttributes","renderSVG","_styleProp","setAttribute","toUpperCase","isVariantLabels","isVariantLabel","resolveVariantFromProps","currentValues","currentVelocity","variants","resolveVariant","getProps","forEachValue","getCurrent","velocity","getVelocity","checkIfControllingVariants","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","isBrowser","document","isRefObject","hasOwnProperty","env","process","isCustomValue","mix","toValue","resolveFinalValueInKeyframes","useConstant","init","useIsomorphicLayoutEffect","useLayoutEffect","isMotionValue","resolveMotionValue","unwrappedValue","parse","parseFloat","alpha","createUnitType","unit","endsWith","split","degrees","percent","vh","vw","progressPercentage","clamp","min","max","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString","extendStatics","d","setPrototypeOf","__proto__","__extends","TypeError","String","__","constructor","create","__assign","t","s","n","__rest","getOwnPropertySymbols","propertyIsEnumerable","__values","o","Symbol","iterator","next","done","__read","r","ar","error","__spreadArray","to","from","pack","l","slice","SuppressedError"],"sourceRoot":""}