identity-admin 1.2.0 → 1.3.0

package/lib/view/static/js/13.d8bc0c19.chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static/js/13.d8bc0c19.chunk.js","mappings":"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","sources":["../node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","../node_modules/framer-motion/dist/es/events/event-info.mjs","../node_modules/framer-motion/dist/es/events/use-dom-event.mjs","../node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","../node_modules/framer-motion/dist/es/events/utils.mjs","../node_modules/framer-motion/dist/es/gestures/PanSession.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","../node_modules/framer-motion/dist/es/render/utils/types.mjs","../node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","../node_modules/framer-motion/dist/es/projection/utils/measure.mjs","../node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","../node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs","../node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","../node_modules/framer-motion/dist/es/motion/features/drag.mjs","../node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","../node_modules/framer-motion/dist/es/utils/use-id.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","../node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","../node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","../node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","../node_modules/framer-motion/dist/es/render/utils/setters.mjs","../node_modules/framer-motion/dist/es/render/utils/animation.mjs","../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","../node_modules/framer-motion/dist/es/motion/features/animations.mjs","../node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","../node_modules/framer-motion/dist/es/motion/features/gestures.mjs","../node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","../node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","../node_modules/framer-motion/dist/es/render/index.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","../node_modules/framer-motion/dist/es/render/html/visual-element.mjs","../node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","../node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","../node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","../node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","../node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","../node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["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","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    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler, options); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    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 { 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","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 { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\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","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = __read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\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","/**\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 { 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","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = __assign(__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return __assign(__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","import { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @internalremarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = useRef(null);\n    var transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\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 { 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 { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\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","import { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/create-projection-node.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(__assign(__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\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","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nexport { isZeroValueString };\n","/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\nexport { testValueType };\n","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\nexport { auto };\n","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes), false), [color, complex], false);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\n\nexport { findValueType };\n","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = __rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = __assign(__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = __spreadArray([], __read(variantLabels), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { setTarget } from './setters.mjs';\nimport { resolveVariant } from './variants.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\n\n/**\n * @internal\n */\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return Promise.resolve(); };\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return Promise.resolve(); };\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    var when = transition.when;\n    if (when) {\n        var _c = __read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = __rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var valueTransition = __assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = __assign(__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, __assign(__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\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);\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined);\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","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 process 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 (process.env.NODE_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 { 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    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), addPointerEvent(window, \"pointercancel\", onPointerCancel));\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);\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    \"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 { __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 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        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 { 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        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 { createProjectionNode } from './create-projection-node.mjs';\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) {\n        ref.addEventListener(\"resize\", notify, { passive: true });\n        return function () { return ref.removeEventListener(\"resize\", notify); };\n    },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { domAnimation } from './features-animation.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign(__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\nexport { domMax };\n"],"names":["isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","point","changedTouches","x","y","pointFromMouse","extractEventInfo","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","button","addDomEvent","target","eventName","options","addEventListener","removeEventListener","useDomEvent","ref","useEffect","element","current","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","isBrowser","window","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent","PanSession","handlers","_a","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance","offset","timestamp","getFrameData","push","__assign","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","sync","end","onEnd","onSessionEnd","panInfo","length","initialInfo","onSessionStart","removeListeners","pipe","prototype","updateHandlers","cancelSync","subtractPoint","a","b","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","secondsToMilliseconds","time","currentVelocity","Infinity","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","calcRelativeAxisConstraints","axis","min","max","undefined","calcViewportAxisConstraints","layoutAxis","constraintsAxis","__read","AnimationType","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","convertBoundingBoxToBox","top","left","right","bottom","measureViewportBox","instance","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","originPoint","constraints","hasMutatedConstraints","elastic","createBox","start","originEvent","_c","snapToCursor","isPresent","panSession","stopAnimation","_b","getProps","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","eachAxis","getAxisMotionValue","get","percent","measuredAxis","layout","actual","calcLength","parseFloat","animationState","setActive","Drag","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","Math","abs","getCurrentDirection","updateAxis","syncRender","stop","getTransformPagePoint","cancel","startAnimation","onDragEnd","_point","shouldDrag","axisValue","next","mix","applyConstraints","set","dragConstraints","prevConstraints","isRefObject","resolveRefConstraints","layoutBox","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","invariant","constraintsBox","rootProjectionNode","viewportBox","scroll","translateAxis","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","transition","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","Promise","all","then","dragKey","toUpperCase","externalMotionValue","getValue","initial","scalePositionWithinConstraints","boxProgress","latest","source","origin","sourceLength","targetLength","progress","clamp","calcOrigin","transformTemplate","getInstance","style","transform","updateScroll","updateLayout","addListeners","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","motionValue","translate","props","_d","_e","_f","useUnmountEffect","callback","makeRenderlessComponent","hook","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","useContext","MotionConfigContext","groupDragControls","dragControls","useConstant","subscribe","counter","incrementId","usePresence","context","PresenceContext","onExitComplete","register","id","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","concat","isCSSVariable","value","startsWith","cssVariableRegex","getVariableValue","depth","match","exec","parseCSSVariable","token","fallback","resolved","getComputedStyle","getPropertyValue","trim","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","replace","shadow","complex","template","xScale","scale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","_super","apply","arguments","__extends","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","addScaleCorrector","defaultScaleCorrectors","group","add","didUpdate","safeToRemove","setOptions","globalProjectionState","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","React__default","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","shallowCompare","prev","Array","isArray","prevLength","isZeroValueString","v","test","testValueType","dimensionValueTypes","number","degrees","vw","vh","parse","findDimensionValueType","find","valueTypes","__spreadArray","color","findValueType","setMotionValue","key","hasValue","addValue","setTarget","definition","resolveVariant","makeTargetAnimatable","transitionEnd","__rest","resolveFinalValueInKeyframes","getOriginFromTransition","from","animateVariant","variant","custom","getDefaultTransition","transitionOverride","getAnimation","animateTarget","resolve","getChildAnimations","variantChildren","size","forwardDelay","delayChildren","staggerChildren","staggerDirection","animations","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","forEach","child","delay","notifyAnimationComplete","animateChildren","when","first","last","animationTypeState","getState","valueTarget","shouldBlockAnimation","valueTransition","shouldReduceMotion","isTransformProp","animation","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","hasOwnProperty","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Exit","reversePriorityOrder","reverse","numAnimationTypes","animateList","map","notifyAnimationStart","resolvedDefinition","animateVisualElement","createAnimationState","animate","state","createTypeState","createState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","getVariantContext","removedKeys","Set","encounteredKeys","removedVariantIndex","_loop_1","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","isAnimationControls","variantDidChange","isVariantLabels","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","delete","isKeyframesTarget","has","blockInitialAnimation","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","isAnimated","setAnimateFunction","makeAnimator","exit","presenceContext","createHoverEvent","isNodeOrChild","parent","parentElement","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","some","useIntersectionObserver","shouldObserve","rootMargin","margin","amount","once","threshold","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","requestAnimationFrame","gestureAnimations","inView","whileInView","viewport","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","removePointerEndListener","call","checkPointerEnd","onPointerUp","onPointerCancel","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","names","BoundingBoxDimension","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","scrapeMotionValuesFromProps","presenceId","visualState","removeFromVariantTree","isMounted","latestValues","renderState","lifecycles","managers","SubscriptionManager","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","_i","notify","createLifecycles","values","Map","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","update","notifyUpdate","bindToMotionValue","removeOnChange","onChange","latestValue","onUpdate","removeOnRenderRequest","onRenderRequest","scheduleRender","initialMotionValues","isMotionValue","isControllingVariants","checkIfControllingVariants","isVariantNode","checkIfVariantNode","children","isVisible","mount","newInstance","addVariantChild","setProps","unmount","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","getLatestValues","setVisibility","visibility","canMutate","removeValue","defaultValue","forEachValue","readValue","setBaseTarget","newProps","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","getVariant","variants","startAtParent","context_1","numVariantProps","name_1","variantProps","positionalKeys","isPositionalKey","setAndResetVelocity","to","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","transformProps","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","checkAndConvertChangedValueTypes","targetPositionalKeys","Object","keys","filter","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","targetBbox","convertChangedValueTypes","unitConversion","hasPositionalKey","parseDomVariant","Element","resolveCSSVariables","htmlConfig","domElement","defaultType","getDefaultValueType","default","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","vars","transformValues","getOrigin","newValueKeys","numNewValues","targetValue","getAnimatableNone","checkTargetForNewValues","parsed","buildHTMLStyles","renderHTML","htmlVisualElement","svgVisualElement","camelCaseAttributes","camelToDash","getAttribute","_element","buildSVGAttrs","renderSVG","domAnimation","renderer","Component","isSVGComponent","enableHardwareAcceleration","DocumentProjectionNode","createProjectionNode","attachResizeListener","passive","measureScroll","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","defaultParent","documentNode","layoutScroll","domMax","projectionNodeConstructor"],"sourceRoot":""}

package/lib/view/static/js/574.f1fff658.chunk.js

@@ -1,2 +0,0 @@
-"use strict";(self.webpackChunk_minimal_material_kit_react=self.webpackChunk_minimal_material_kit_react||[]).push([[574],{65574:function(e,n,i){i.r(n),i.d(n,{default:function(){return x}});var t=i(11617),r=i(11087),a=i(47630),o=i(26445),s=i(20890),c=i(36151),l=i(53451),d=i(99060),h=i(70705),m=i(80184),u=(0,a.ZP)("div")((function(e){return{maxWidth:480,margin:"auto",minHeight:"100vh",display:"flex",justifyContent:"center",flexDirection:"column",padding:e.theme.spacing(12,0)}}));function x(){return(0,m.jsx)(l.Z,{title:"404 Page Not Found",children:(0,m.jsx)(o.Z,{component:d.NM,children:(0,m.jsxs)(u,{sx:{textAlign:"center",alignItems:"center"},children:[(0,m.jsx)(t.m.div,{variants:(0,d.Wp)().in,children:(0,m.jsx)(s.Z,{variant:"h3",paragraph:!0,children:"Sorry, page not found!"})}),(0,m.jsx)(t.m.div,{variants:(0,d.Wp)().in,children:(0,m.jsx)(s.Z,{sx:{color:"text.secondary"},children:"Sorry, we couldn\u2019t find the page you\u2019re looking for. Perhaps you\u2019ve mistyped the URL? Be sure to check your spelling."})}),(0,m.jsx)(t.m.div,{variants:(0,d.Wp)().in,children:(0,m.jsx)(h.CE,{sx:{height:260,my:{xs:5,sm:10}}})}),(0,m.jsx)(c.Z,{to:"/admin",size:"large",variant:"contained",component:r.rU,children:"Go to Home"})]})})})}}}]);
-//# sourceMappingURL=574.f1fff658.chunk.js.map

package/lib/view/static/js/574.f1fff658.chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static/js/574.f1fff658.chunk.js","mappings":"+SAaMA,GAAeC,EAAAA,EAAAA,IAAO,MAAPA,EAAc,kBAAgB,CACjDC,SAAU,IACVC,OAAQ,OACRC,UAAW,QACXC,QAAS,OACTC,eAAgB,SAChBC,cAAe,SACfC,QAPiC,EAAGC,MAOrBC,QAAQ,GAAI,OAKd,SAASC,IACtB,OACE,SAAC,IAAD,CAAMC,MAAM,qBAAZ,UACE,SAAC,IAAD,CAAWC,UAAWC,EAAAA,GAAtB,UACE,UAACd,EAAD,CAAce,GAAI,CAAEC,UAAW,SAAUC,WAAY,UAArD,WACE,SAAC,EAAAC,EAAA,IAAD,CAAOC,UAAUC,EAAAA,EAAAA,MAAYC,GAA7B,UACE,SAAC,IAAD,CAAYC,QAAQ,KAAKC,WAAS,EAAlC,uCAKF,SAAC,EAAAL,EAAA,IAAD,CAAOC,UAAUC,EAAAA,EAAAA,MAAYC,GAA7B,UACE,SAAC,IAAD,CAAYN,GAAI,CAAES,MAAO,kBAAzB,qJAMF,SAAC,EAAAN,EAAA,IAAD,CAAOC,UAAUC,EAAAA,EAAAA,MAAYC,GAA7B,UACE,SAAC,KAAD,CAA0BN,GAAI,CAAEU,OAAQ,IAAKC,GAAI,CAAEC,GAAI,EAAGC,GAAI,UAGhE,SAAC,IAAD,CAAQC,GAAG,SAASC,KAAK,QAAQR,QAAQ,YAAYT,UAAWkB,EAAAA,GAAhE","sources":["pages/Page404.tsx"],"sourcesContent":["import { m } from 'framer-motion';\nimport { Link as RouterLink } from 'react-router-dom';\n// @mui\nimport { styled } from '@mui/material/styles';\nimport { Button, Typography, Container } from '@mui/material';\n// components\nimport Page from '../components/Page';\nimport { MotionContainer, varBounce } from '../components/animate';\n// assets\nimport { PageNotFoundIllustration } from '../assets';\n\n// ----------------------------------------------------------------------\n\nconst ContentStyle = styled('div')(({ theme }) => ({\n  maxWidth: 480,\n  margin: 'auto',\n  minHeight: '100vh',\n  display: 'flex',\n  justifyContent: 'center',\n  flexDirection: 'column',\n  padding: theme.spacing(12, 0),\n}));\n\n// ----------------------------------------------------------------------\n\nexport default function Page404() {\n  return (\n    <Page title=\"404 Page Not Found\">\n      <Container component={MotionContainer}>\n        <ContentStyle sx={{ textAlign: 'center', alignItems: 'center' }}>\n          <m.div variants={varBounce().in}>\n            <Typography variant=\"h3\" paragraph>\n              Sorry, page not found!\n            </Typography>\n          </m.div>\n\n          <m.div variants={varBounce().in}>\n            <Typography sx={{ color: 'text.secondary' }}>\n              Sorry, we couldn’t find the page you’re looking for. Perhaps you’ve mistyped the URL?\n              Be sure to check your spelling.\n            </Typography>\n          </m.div>\n\n          <m.div variants={varBounce().in}>\n            <PageNotFoundIllustration sx={{ height: 260, my: { xs: 5, sm: 10 } }} />\n          </m.div>\n\n          <Button to=\"/admin\" size=\"large\" variant=\"contained\" component={RouterLink} >\n            Go to Home\n          </Button>\n        </ContentStyle>\n      </Container>\n    </Page>\n  );\n}\n"],"names":["ContentStyle","styled","maxWidth","margin","minHeight","display","justifyContent","flexDirection","padding","theme","spacing","Page404","title","component","MotionContainer","sx","textAlign","alignItems","m","variants","varBounce","in","variant","paragraph","color","height","my","xs","sm","to","size","RouterLink"],"sourceRoot":""}

package/lib/view/static/js/678.fddff388.chunk.js

@@ -1,2 +0,0 @@
-"use strict";(self.webpackChunk_minimal_material_kit_react=self.webpackChunk_minimal_material_kit_react||[]).push([[678],{19678:function(a,e,i){i.r(e);var t=i(87013);e.default=t.g}}]);
-//# sourceMappingURL=678.fddff388.chunk.js.map

package/lib/view/static/js/678.fddff388.chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static/js/678.fddff388.chunk.js","mappings":"sKAEA,UAAeA,EAAf","sources":["components/animate/features.js"],"sourcesContent":["import { domMax } from 'framer-motion';\n\nexport default domMax;\n"],"names":["domMax"],"sourceRoot":""}