{"version":3,"file":"3082-0d3605d6f611a60d7a28.js","mappings":"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","sources":["webpack://brc/./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack://brc/./node_modules/framer-motion/dist/es/components/LazyMotion/index.mjs","webpack://brc/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://brc/./node_modules/framer-motion/dist/es/events/use-dom-event.mjs","webpack://brc/./node_modules/framer-motion/dist/es/events/utils.mjs","webpack://brc/./node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","webpack://brc/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack://brc/./node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","webpack://brc/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://brc/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://brc/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://brc/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://brc/./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","webpack://brc/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/warn-once.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","webpack://brc/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://brc/./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","webpack://brc/./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/index.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/html/visual-element.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://brc/./node_modules/framer-motion/dist/es/render/utils/types.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/use-id.mjs","webpack://brc/./node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs"],"sourcesContent":["import { useContext, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useId } from '../../utils/use-id.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    var context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    var id = useId();\n    useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { __read, __rest } from 'tslib';\nimport * as React from 'react';\nimport { useState, useRef, useEffect } from 'react';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { loadFeatures } from '../../motion/features/definitions.mjs';\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = __read(useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = __rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = __rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\nexport { LazyMotion };\n","import { isTouchEvent } from '../gestures/utils/event-type.mjs';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, wrapHandler };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","import { isBrowser } from '../utils/is-browser.mjs';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nexport { addPointerEvent, usePointerEvent };\n","function createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","function isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\nexport { isMouseEvent, isTouchEvent };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    var distanceFromOrigin = point - originPoint;\n    var scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys);\n    transformAxis(box.y, transform, yKeys);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { hasScale, hasTransform };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","import { __spreadArray, __read, __assign, __rest } from 'tslib';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { AnimationType } from './types.mjs';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.mjs';\n\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = __rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = __assign(__assign(__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\n    }\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        var animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        var removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        var encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            var activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = __assign({}, encounteredKeys);\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                return \"continue\";\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            var variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = __assign(__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = __assign(__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, __spreadArray([], __read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: __assign({ type: type }, options),\n                }); })), false));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = __assign({}, encounteredKeys);\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[AnimationType.Animate] = createTypeState(true),\n        _a[AnimationType.InView] = createTypeState(),\n        _a[AnimationType.Hover] = createTypeState(),\n        _a[AnimationType.Tap] = createTypeState(),\n        _a[AnimationType.Drag] = createTypeState(),\n        _a[AnimationType.Focus] = createTypeState(),\n        _a[AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nexport { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { createAnimationState } from '../../render/utils/animation-state.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","import { isMouseEvent } from './utils/event-type.mjs';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\nexport { useHoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","var warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n","import { __rest, __assign } from 'tslib';\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = __rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, __assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { env } from '../../../utils/process.mjs';\nimport { useRef, useEffect } from 'react';\nimport { AnimationType } from '../../../render/utils/types.mjs';\nimport { warnOnce } from '../../../utils/warn-once.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nexport { useViewport };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.mjs';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.mjs';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.mjs';\nimport { useViewport } from './viewport/use-viewport.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === number || v === px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (key) {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = __assign({}, target);\n    transitionEnd = __assign({}, transitionEnd);\n    var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var fromType = findDimensionValueType(from);\n        var to = target[key];\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                var current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = __read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\nexport { BoundingBoxDimension, positionalValues, unitConversion };\n","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = useRef(false);\n    var cancelPointerEndListeners = useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.mjs';\nimport { useDomEvent } from '../events/use-dom-event.mjs';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nexport { useFocusGesture };\n","import { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, __spreadArray([], __read(args), false));\n        };\n    });\n    return lifecycles;\n}\n\nexport { createLifecycles };\n","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { createLifecycles } from './utils/lifecycles.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.mjs';\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = __assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync.update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = __assign(__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                cancelSync.update(update);\n                cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            }, \n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\n            }, \n            /**\n             * Measure the current viewport box with or without transforms.\n             * Only measures axis-aligned boxes, rotate and skew must be manually\n             * removed with a re-render to work.\n             */\n            measureViewportBox: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \n            /**\n             * If we're trying to animate to a previously unencountered value,\n             * we need to check for it in our state and as a last resort read it\n             * directly from the instance (which might have performance implications).\n             */\n            readValue: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n            }, \n            /**\n             * Set the base target to later animate back to. This is currently\n             * only hydrated on creation and when we first read a value.\n             */\n            setBaseTarget: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync.render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \n            /**\n             * Update the provided props. Ensure any newly-added motion values are\n             * added to our map, old ones removed, and listeners updated.\n             */\n            setProps: function (newProps) {\n                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nexport { visualElement };\n","import { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs';\nimport { isTransformProp } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle(domElement);\n            return ((isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    },\n    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return __assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n","import { __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { htmlConfig } from '../html/visual-element.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\n\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nexport { svgVisualElement };\n","import { __assign } from 'tslib';\nimport { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nvar domAnimation = __assign(__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\nexport { domAnimation };\n","import { htmlVisualElement } from '../html/visual-element.mjs';\nimport { svgVisualElement } from '../svg/visual-element.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { __rest, __assign, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = __read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\".concat(current, \"\\\". This may indicate a circular fallback dependency.\"));\n    var _a = __read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = __rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof Element))\n        return { target: target, transitionEnd: transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = __assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","var AnimationType;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\n","import { useConstant } from './use-constant.mjs';\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\nexport { useId };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\n"],"names":["usePresence","context","useContext","isPresent","onExitComplete","register","id","useEffect","LazyMotion","_a","children","features","_b","strict","setIsLoaded","useState","isLazyBundle","loadedRenderer","useRef","undefined","renderer","loadedFeatures","current","then","Provider","value","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","point","touches","changedTouches","x","y","pointFromMouse","extractEventInfo","event","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","isMouseEvent","MouseEvent","button","addDomEvent","target","eventName","options","passive","addEventListener","removeEventListener","useDomEvent","ref","element","supportsPointerEvents","window","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","PointerEvent","pointerType","isTouchEvent","makeRenderlessComponent","hook","props","convertBoundingBoxToBox","top","min","left","max","right","bottom","convertBoxToBoundingBox","transformBoxPoints","transformPoint","topLeft","bottomRight","scalePoint","scale","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","length","node","delta","i","projectionDelta","instance","style","display","layoutScroll","scroll","root","transformBox","latestValues","translateAxis","distance","transformAxis","transforms","key","scaleKey","originKey","axisOrigin","xKeys","yKeys","transform","isIdentityScale","hasScale","scaleX","scaleY","hasTransform","values","hasTranslate","z","rotate","rotateX","rotateY","measureViewportBox","getBoundingClientRect","measurePageBox","rootProjectionNode","transformPagePoint","viewportBox","shallowCompare","next","prev","Array","isArray","prevLength","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Drag","Exit","reversePriorityOrder","reverse","numAnimationTypes","createTypeState","isActive","protectedKeys","needsAnimating","prevResolvedValues","animations","animation","visualElement","animate","animationState","Promise","all","map","animateList","state","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","definition","resolved","transition","transitionEnd","animateChanges","changedActiveType","getProps","getVariantContext","removedKeys","Set","encounteredKeys","removedVariantIndex","Infinity","_loop_1","type","typeState","prop","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","allKeys","markToAnimate","delete","hasOwnProperty","add","has","blockInitialAnimation","push","apply","size","fallbackAnimation_1","forEach","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","initial","resolve","isAnimated","setActive","variantChildren","child","setAnimateFunction","makeAnimator","getState","createAnimationState","subscribe","exit","custom","safeToRemove","presenceContext","PresenceContext","createHoverEvent","callback","info","isNodeOrChild","parent","parentElement","warned","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","get","fireAllObserverCallbacks","entries","thresholdNames","some","useIntersectionObserver","shouldObserve","rootMargin","margin","amount","once","threshold","rootInteresectionObserver","lookupRoot","document","set","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","observeIntersection","getInstance","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","fallback","message","console","warn","requestAnimationFrame","BoundingBoxDimension","gestureAnimations","inView","whileInView","viewport","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","call","checkPointerEnd","onPointerUp","onPointerCancel","pipe","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","names","treeType","build","makeTargetAnimatable","renderInstance","render","readValueFromInstance","removeValueFromRenderState","sortNodePosition","scrapeMotionValuesFromProps","presenceId","visualState","shouldReduceMotion","removeFromVariantTree","isMounted","renderState","lifecycles","managers","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","_i","arguments","notify","createLifecycles","Map","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","projection","update","notifyUpdate","bindToMotionValue","removeOnChange","onChange","latestValue","onUpdate","removeOnRenderRequest","onRenderRequest","scheduleRender","initialMotionValues","isControllingVariants","isVariantNode","depth","isVisible","mount","newInstance","addVariantChild","setProps","unmount","remove","closestVariantNode","getClosestVariantNode","other","getLayoutId","layoutId","getStaticValue","setStaticValue","getLatestValues","setVisibility","visibility","canMutate","addValue","hasValue","removeValue","getValue","defaultValue","forEachValue","readValue","setBaseTarget","syncRender","newProps","transformTemplate","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","getVariant","variants","getDefaultTransition","getTransformPagePoint","startAtParent","context_1","numVariantProps","name_1","variantProps","positionalKeys","isPositionalKey","setAndResetVelocity","to","isNumOrPxType","v","px","getPosFromMatrix","matrix","pos","parseFloat","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","match","transformKeys","nonTranslationalTransformKeys","filter","positionalValues","width","_c","paddingLeft","_d","paddingRight","height","paddingTop","paddingBottom","unitConversion","origin","Object","keys","hasPositionalKey","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","from","fromType","numKeyframes","fromIndex","removedTransforms","startsWith","removeNonTranslationalTransform","scrollY_1","indexOf","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","getComputedStyle","targetBbox","convertChangedValueTypes","scrollTo","checkAndConvertChangedValueTypes","htmlConfig","domElement","defaultType","default","computedStyle","getPropertyValue","a","b","compareDocumentPosition","measure","m","resetTransform","restoreTransform","mutableState","vars","transformValues","parsed","parseDomVariant","htmlVisualElement","svgVisualElement","getAttribute","_element","domAnimation","Component","enableHardwareAcceleration","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","concat","exec","parseCSSVariable","token","trim","resolveCSSVariables","Element","AnimationType","counter","incrementId","useId","useUnmountEffect"],"sourceRoot":""}