@televet/kibble-ui 1.20.21-beta.cs2 → 1.20.21-beta.cs21

package/build/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VisualElementDragControls.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js"],"sourcesContent":["import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.js';\nimport { getGlobalLock } from './utils/lock.js';\nimport { isRefObject } from '../../utils/is-ref-object.js';\nimport { addPointerEvent } from '../../events/use-pointer-event.js';\nimport { addDomEvent } from '../../events/use-dom-event.js';\nimport { getViewportPointFromEvent } from '../../events/event-info.js';\nimport { axisBox, convertAxisBoxToBoundingBox, convertBoundingBoxToAxisBox } from '../../utils/geometry/index.js';\nimport { eachAxis } from '../../utils/each-axis.js';\nimport { calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, applyConstraints, calcConstrainedMinPoint, calcPositionFromProgress, defaultElastic } from './utils/constraints.js';\nimport { getBoundingBox } from '../../render/dom/projection/measure.js';\nimport { calcOrigin } from '../../utils/geometry/delta-calc.js';\nimport { startAnimation } from '../../animation/utils/transitions.js';\nimport { AnimationType } from '../../render/utils/types.js';\nimport { collectProjectingAncestors, updateLayoutMeasurement, collectProjectingChildren } from '../../render/dom/projection/utils.js';\nimport { progress } from 'popmotion';\nimport { convertToRelativeProjection } from '../../render/dom/projection/convert-to-relative.js';\nimport { calcRelativeOffset } from '../../motion/features/layout/utils.js';\nimport { flushLayout, batchLayout } from '../../render/dom/utils/batch-layout.js';\nimport { flushSync } from 'framesync';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\nvar lastPointerEvent;\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(_a) {\n        var visualElement = _a.visualElement;\n        /**\n         * Track whether we're currently dragging.\n         *\n         * @internal\n         */\n        this.isDragging = false;\n        /**\n         * The current direction of drag, or `null` if both.\n         *\n         * @internal\n         */\n        this.currentDirection = null;\n        /**\n         * The permitted boundaries of travel, in pixels.\n         *\n         * @internal\n         */\n        this.constraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         *\n         * @internal\n         */\n        this.elastic = axisBox();\n        /**\n         * A reference to the host component's latest props.\n         *\n         * @internal\n         */\n        this.props = {};\n        /**\n         * @internal\n         */\n        this.hasMutatedConstraints = false;\n        /**\n         * Track the initial position of the cursor relative to the dragging element\n         * when dragging starts as a value of 0-1 on each axis. We then use this to calculate\n         * an ideal bounding box for the VisualElement renderer to project into every frame.\n         *\n         * @internal\n         */\n        this.cursorProgress = {\n            x: 0.5,\n            y: 0.5,\n        };\n        // When updating _dragX, or _dragY instead of the VisualElement,\n        // persist their values between drag gestures.\n        this.originPoint = {};\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        /**\n         * @internal\n         */\n        this.panSession = null;\n        this.visualElement = visualElement;\n        this.visualElement.enableLayoutProjection();\n        elementDragControls.set(visualElement, this);\n    }\n    /**\n     * Instantiate a PanSession for the drag gesture\n     *\n     * @public\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, cursorProgress = _b.cursorProgress;\n        var onSessionStart = function (event) {\n            var _a;\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopMotion();\n            /**\n             * Save the initial point. We'll use this to calculate the pointer's position rather\n             * than the one we receive when the gesture actually starts. By then, the pointer will\n             * have already moved, and the perception will be of the pointer \"slipping\" across the element\n             */\n            var initialPoint = getViewportPointFromEvent(event).point;\n            (_a = _this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(_this);\n            _this.cancelLayout = batchLayout(function (read, write) {\n                var ancestors = collectProjectingAncestors(_this.visualElement);\n                var children = collectProjectingChildren(_this.visualElement);\n                var tree = __spreadArray(__spreadArray([], __read(ancestors)), __read(children));\n                var hasManuallySetCursorOrigin = false;\n                /**\n                 * Apply a simple lock to the projection target. This ensures no animations\n                 * can run on the projection box while this lock is active.\n                 */\n                _this.isLayoutDrag() && _this.visualElement.lockProjectionTarget();\n                write(function () {\n                    tree.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    updateLayoutMeasurement(_this.visualElement);\n                    children.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    tree.forEach(function (element) { return element.restoreTransform(); });\n                    if (snapToCursor) {\n                        hasManuallySetCursorOrigin = _this.snapToCursor(initialPoint);\n                    }\n                });\n                read(function () {\n                    var isRelativeDrag = Boolean(_this.getAxisMotionValue(\"x\") && !_this.isExternalDrag());\n                    if (!isRelativeDrag) {\n                        _this.visualElement.rebaseProjectionTarget(true, _this.visualElement.measureViewportBox(false));\n                    }\n                    _this.visualElement.scheduleUpdateLayoutProjection();\n                    /**\n                     * When dragging starts, we want to find where the cursor is relative to the bounding box\n                     * of the element. Every frame, we calculate a new bounding box using this relative position\n                     * and let the visualElement renderer figure out how to reproject the element into this bounding\n                     * box.\n                     *\n                     * By doing it this way, rather than applying an x/y transform directly to the element,\n                     * we can ensure the component always visually sticks to the cursor as we'd expect, even\n                     * if the DOM element itself changes layout as a result of React updates the user might\n                     * make based on the drag position.\n                     */\n                    var projection = _this.visualElement.projection;\n                    eachAxis(function (axis) {\n                        if (!hasManuallySetCursorOrigin) {\n                            var _a = projection.target[axis], min = _a.min, max = _a.max;\n                            _this.cursorProgress[axis] = cursorProgress\n                                ? cursorProgress[axis]\n                                : progress(min, max, initialPoint[axis]);\n                        }\n                        /**\n                         * If we have external drag MotionValues, record their origin point. On pointermove\n                         * we'll apply the pan gesture offset directly to this value.\n                         */\n                        var axisValue = _this.getAxisMotionValue(axis);\n                        if (axisValue) {\n                            _this.originPoint[axis] = axisValue.get();\n                        }\n                    });\n                });\n                write(function () {\n                    flushSync.update();\n                    flushSync.preRender();\n                    flushSync.render();\n                    flushSync.postRender();\n                });\n                read(function () { return _this.resolveDragConstraints(); });\n            });\n        };\n        var onStart = function (event, info) {\n            var _a, _b, _c;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _d = _this.props, drag = _d.drag, dragPropagation = _d.dragPropagation;\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            flushLayout();\n            // Set current drag status\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            // Fire onDragStart event\n            (_b = (_a = _this.props).onDragStart) === null || _b === void 0 ? void 0 : _b.call(_a, event, info);\n            (_c = _this.visualElement.animationState) === null || _c === void 0 ? void 0 : _c.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            var _a, _b, _c, _d;\n            var _e = _this.props, dragPropagation = _e.dragPropagation, dragDirectionLock = _e.dragDirectionLock;\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                    (_b = (_a = _this.props).onDirectionLock) === null || _b === void 0 ? void 0 : _b.call(_a, _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            // Fire onDrag event\n            (_d = (_c = _this.props).onDrag) === null || _d === void 0 ? void 0 : _d.call(_c, event, info);\n            // Update the last pointer event\n            lastPointerEvent = event;\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        var transformPagePoint = this.props.transformPagePoint;\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: transformPagePoint });\n    };\n    VisualElementDragControls.prototype.resolveDragConstraints = function () {\n        var _this = this;\n        var _a = this.props, dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = this.visualElement.getLayoutState().layoutCorrected;\n        if (dragConstraints) {\n            this.constraints = isRefObject(dragConstraints)\n                ? this.resolveRefConstraints(layout, dragConstraints)\n                : calcRelativeConstraints(layout, dragConstraints);\n        }\n        else {\n            this.constraints = false;\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 (this.constraints && !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function (layoutBox, constraints) {\n        var _a = this.props, onMeasureDragConstraints = _a.onMeasureDragConstraints, transformPagePoint = _a.transformPagePoint;\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        this.constraintsBox = getBoundingBox(constraintsElement, transformPagePoint);\n        var measuredConstraints = calcViewportConstraints(layoutBox, this.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(convertAxisBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToAxisBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.cancelDrag = function () {\n        var _a, _b;\n        this.visualElement.unlockProjectionTarget();\n        (_a = this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(this);\n        this.isDragging = false;\n        this.panSession && this.panSession.end();\n        this.panSession = null;\n        if (!this.props.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.stop = function (event, info) {\n        var _a, _b, _c;\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = null;\n        var isDragging = this.isDragging;\n        this.cancelDrag();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.animateDragEnd(velocity);\n        (_c = (_b = this.props).onDragEnd) === null || _c === void 0 ? void 0 : _c.call(_b, event, info);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        return eachAxis(function (axis) {\n            var drag = _this.props.drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var box = _this.visualElement.getLayoutState().layout;\n                var length_1 = box[axis].max - box[axis].min;\n                var center = box[axis].min + length_1 / 2;\n                var offset = point[axis] - center;\n                _this.originPoint[axis] = point[axis];\n                axisValue.set(offset);\n            }\n            else {\n                _this.cursorProgress[axis] = 0.5;\n                return true;\n            }\n        }).includes(true);\n    };\n    /**\n     * Update the specified axis with the latest pointer information.\n     */\n    VisualElementDragControls.prototype.updateAxis = function (axis, point, offset) {\n        var drag = this.props.drag;\n        // If we're not dragging this axis, do an early return.\n        if (!shouldDrag(axis, drag, this.currentDirection))\n            return;\n        return this.getAxisMotionValue(axis)\n            ? this.updateAxisMotionValue(axis, offset)\n            : this.updateVisualElementAxis(axis, point);\n    };\n    VisualElementDragControls.prototype.updateAxisMotionValue = function (axis, offset) {\n        var axisValue = this.getAxisMotionValue(axis);\n        if (!offset || !axisValue)\n            return;\n        var nextValue = this.originPoint[axis] + offset[axis];\n        var update = this.constraints\n            ? applyConstraints(nextValue, this.constraints[axis], this.elastic[axis])\n            : nextValue;\n        axisValue.set(update);\n    };\n    VisualElementDragControls.prototype.updateVisualElementAxis = function (axis, point) {\n        var _a;\n        // Get the actual layout bounding box of the element\n        var axisLayout = this.visualElement.getLayoutState().layout[axis];\n        // Calculate its current length. In the future we might want to lerp this to animate\n        // between lengths if the layout changes as we change the DOM\n        var axisLength = axisLayout.max - axisLayout.min;\n        // Get the initial progress that the pointer sat on this axis on gesture start.\n        var axisProgress = this.cursorProgress[axis];\n        // Calculate a new min point based on the latest pointer position, constraints and elastic\n        var min = calcConstrainedMinPoint(point[axis], axisLength, axisProgress, (_a = this.constraints) === null || _a === void 0 ? void 0 : _a[axis], this.elastic[axis]);\n        // Update the axis viewport target with this new min and the length\n        this.visualElement.setProjectionTargetAxis(axis, min, min + axisLength);\n    };\n    VisualElementDragControls.prototype.setProps = function (_a) {\n        var _b = _a.drag, drag = _b === void 0 ? false : _b, _c = _a.dragDirectionLock, dragDirectionLock = _c === void 0 ? false : _c, _d = _a.dragPropagation, dragPropagation = _d === void 0 ? false : _d, _e = _a.dragConstraints, dragConstraints = _e === void 0 ? false : _e, _f = _a.dragElastic, dragElastic = _f === void 0 ? defaultElastic : _f, _g = _a.dragMomentum, dragMomentum = _g === void 0 ? true : _g, remainingProps = __rest(_a, [\"drag\", \"dragDirectionLock\", \"dragPropagation\", \"dragConstraints\", \"dragElastic\", \"dragMomentum\"]);\n        this.props = __assign({ drag: drag,\n            dragDirectionLock: dragDirectionLock,\n            dragPropagation: dragPropagation,\n            dragConstraints: dragConstraints,\n            dragElastic: dragElastic,\n            dragMomentum: dragMomentum }, remainingProps);\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     * - If the component will perform layout animations, we output the gesture to the component's\n     *      visual bounding box\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a = this.props, layout = _a.layout, layoutId = _a.layoutId;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        if (this.props[dragKey]) {\n            return this.props[dragKey];\n        }\n        else if (!layout && layoutId === undefined) {\n            return this.visualElement.getValue(axis, 0);\n        }\n    };\n    VisualElementDragControls.prototype.isLayoutDrag = function () {\n        return !this.getAxisMotionValue(\"x\");\n    };\n    VisualElementDragControls.prototype.isExternalDrag = function () {\n        var _a = this.props, _dragX = _a._dragX, _dragY = _a._dragY;\n        return _dragX || _dragY;\n    };\n    VisualElementDragControls.prototype.animateDragEnd = function (velocity) {\n        var _this = this;\n        var _a = this.props, drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition;\n        /**\n         * Everything beyond the drag gesture should be performed with\n         * relative projection so children stay in sync with their parent element.\n         */\n        var isRelative = convertToRelativeProjection(this.visualElement, this.isLayoutDrag() && !this.isExternalDrag());\n        /**\n         * If we had previously resolved constraints relative to the viewport,\n         * we need to also convert those to a relative coordinate space for the animation\n         */\n        var constraints = this.constraints || {};\n        if (isRelative &&\n            Object.keys(constraints).length &&\n            this.isLayoutDrag()) {\n            var projectionParent = this.visualElement.getProjectionParent();\n            if (projectionParent) {\n                var relativeConstraints_1 = calcRelativeOffset(projectionParent.projection.targetFinal, constraints);\n                eachAxis(function (axis) {\n                    var _a = relativeConstraints_1[axis], min = _a.min, max = _a.max;\n                    constraints[axis] = {\n                        min: isNaN(min) ? undefined : min,\n                        max: isNaN(max) ? undefined : max,\n                    };\n                });\n            }\n        }\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            /**\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,\n                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.getAxisMotionValue(axis)\n                ? _this.startAxisValueAnimation(axis, inertia)\n                : _this.visualElement.startLayoutAnimation(axis, inertia, isRelative);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(function () {\n            var _a, _b;\n            (_b = (_a = _this.props).onDragTransitionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);\n        });\n    };\n    VisualElementDragControls.prototype.stopMotion = function () {\n        var _this = this;\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            axisValue\n                ? axisValue.stop()\n                : _this.visualElement.stopLayoutAnimation();\n        });\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        if (!axisValue)\n            return;\n        var currentValue = axisValue.get();\n        axisValue.set(currentValue);\n        axisValue.set(currentValue); // Set twice to hard-reset velocity\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.scalePoint = function () {\n        var _this = this;\n        var _a = this.props, drag = _a.drag, dragConstraints = _a.dragConstraints;\n        if (!isRefObject(dragConstraints) || !this.constraintsBox)\n            return;\n        // Stop any current animations as there can be some visual glitching if we resize mid animation\n        this.stopMotion();\n        // Record the relative progress of the targetBox relative to the constraintsBox\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            boxProgress[axis] = calcOrigin(_this.visualElement.projection.target[axis], _this.constraintsBox[axis]);\n        });\n        /**\n         * For each axis, calculate the current progress of the layout axis within the constraints.\n         * Then, using the latest layout and constraints measurements, reposition the new layout axis\n         * proportionally within the constraints.\n         */\n        this.updateConstraints(function () {\n            eachAxis(function (axis) {\n                if (!shouldDrag(axis, drag, null))\n                    return;\n                // Calculate the position of the targetBox relative to the constraintsBox using the\n                // previously calculated progress\n                var _a = calcPositionFromProgress(_this.visualElement.projection.target[axis], _this.constraintsBox[axis], boxProgress[axis]), min = _a.min, max = _a.max;\n                _this.visualElement.setProjectionTargetAxis(axis, min, max);\n            });\n        });\n        /**\n         * If any other draggable components are queuing the same tasks synchronously\n         * this will wait until they've all been scheduled before flushing.\n         */\n        setTimeout(flushLayout, 1);\n    };\n    VisualElementDragControls.prototype.updateConstraints = function (onReady) {\n        var _this = this;\n        this.cancelLayout = batchLayout(function (read, write) {\n            var ancestors = collectProjectingAncestors(_this.visualElement);\n            write(function () {\n                return ancestors.forEach(function (element) { return element.resetTransform(); });\n            });\n            read(function () { return updateLayoutMeasurement(_this.visualElement); });\n            write(function () {\n                return ancestors.forEach(function (element) { return element.restoreTransform(); });\n            });\n            read(function () {\n                _this.resolveDragConstraints();\n            });\n            if (onReady)\n                write(onReady);\n        });\n    };\n    VisualElementDragControls.prototype.mount = function (visualElement) {\n        var _this = this;\n        var element = 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.props, drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\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.scalePoint();\n        });\n        /**\n         * Ensure drag constraints are resolved correctly relative to the dragging element\n         * whenever its layout changes.\n         */\n        var stopLayoutUpdateListener = visualElement.onLayoutUpdate(function () {\n            if (_this.isDragging) {\n                _this.resolveDragConstraints();\n            }\n        });\n        /**\n         * If the previous component with this same layoutId was dragging at the time\n         * it was unmounted, we want to continue the same gesture on this component.\n         */\n        var prevDragCursor = visualElement.prevDragCursor;\n        if (prevDragCursor) {\n            this.start(lastPointerEvent, { cursorProgress: prevDragCursor });\n        }\n        /**\n         * Return a function that will teardown the drag gesture\n         */\n        return function () {\n            stopPointerListener === null || stopPointerListener === void 0 ? void 0 : stopPointerListener();\n            stopResizeListener === null || stopResizeListener === void 0 ? void 0 : stopResizeListener();\n            stopLayoutUpdateListener === null || stopLayoutUpdateListener === void 0 ? void 0 : stopLayoutUpdateListener();\n            _this.cancelDrag();\n        };\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"],"names":["lastPointerEvent","elementDragControls","WeakMap","VisualElementDragControls","_a","visualElement","this","isDragging","currentDirection","constraints","elastic","axisBox","props","hasMutatedConstraints","cursorProgress","x","y","originPoint","openGlobalLock","panSession","enableLayoutProjection","set","prototype","start","originEvent","_this","_b","_c","snapToCursor","transformPagePoint","PanSession","onSessionStart","event","stopMotion","initialPoint","getViewportPointFromEvent","point","cancelLayout","call","batchLayout","read","write","ancestors","collectProjectingAncestors","children","collectProjectingChildren","tree","__spreadArray","__read","hasManuallySetCursorOrigin","isLayoutDrag","lockProjectionTarget","forEach","element","resetTransform","updateLayoutMeasurement","restoreTransform","Boolean","getAxisMotionValue","isExternalDrag","rebaseProjectionTarget","measureViewportBox","scheduleUpdateLayoutProjection","projection","eachAxis","axis","target","min","max","progress","axisValue","get","flushSync","update","preRender","render","postRender","resolveDragConstraints","onStart","info","_d","drag","dragPropagation","getGlobalLock","flushLayout","onDragStart","animationState","setActive","AnimationType","Drag","onMove","_e","dragDirectionLock","offset","lockThreshold","direction","Math","abs","getCurrentDirection","onDirectionLock","updateAxis","onDrag","onSessionEnd","stop","dragConstraints","dragElastic","layout","getLayoutState","layoutCorrected","isRefObject","resolveRefConstraints","calcRelativeConstraints","resolveDragElastic","rebaseAxisConstraints","layoutBox","onMeasureDragConstraints","constraintsElement","current","invariant","constraintsBox","getBoundingBox","measuredConstraints","calcViewportConstraints","userConstraints","convertAxisBoxToBoundingBox","convertBoundingBoxToAxisBox","cancelDrag","unlockProjectionTarget","end","velocity","animateDragEnd","onDragEnd","shouldDrag","box","length_1","center","includes","updateAxisMotionValue","updateVisualElementAxis","nextValue","applyConstraints","axisLayout","axisLength","axisProgress","calcConstrainedMinPoint","setProjectionTargetAxis","setProps","_f","defaultElastic","_g","dragMomentum","remainingProps","__rest","__assign","layoutId","dragKey","toUpperCase","undefined","getValue","_dragX","_dragY","dragTransition","isRelative","convertToRelativeProjection","Object","keys","length","projectionParent","getProjectionParent","relativeConstraints_1","calcRelativeOffset","targetFinal","isNaN","momentumAnimations","transition","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","startLayoutAnimation","Promise","all","then","onDragTransitionEnd","stopLayoutAnimation","currentValue","startAnimation","scalePoint","boxProgress","calcOrigin","updateConstraints","calcPositionFromProgress","setTimeout","onReady","mount","getInstance","stopPointerListener","addPointerEvent","dragListener","stopResizeListener","addDomEvent","window","stopLayoutUpdateListener","onLayoutUpdate","prevDragCursor"],"mappings":"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"}

package/build/node_modules/framer-motion/dist/es/gestures/drag/use-drag.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../tslib/tslib.es6.js"),t=require("react"),n=require("../../context/MotionConfigContext.js"),s=require("./VisualElementDragControls.js"),r=require("../../utils/use-constant.js");exports.useDrag=function(o){var u=o.dragControls,i=o.visualElement,a=t.useContext(n.MotionConfigContext).transformPagePoint,l=r.useConstant((function(){return new s.VisualElementDragControls({visualElement:i})}));l.setProps(e.__assign(e.__assign({},o),{transformPagePoint:a})),t.useEffect((function(){return u&&u.subscribe(l)}),[l]),t.useEffect((function(){return l.mount(i)}),[])};
+//# sourceMappingURL=use-drag.js.map

package/build/node_modules/framer-motion/dist/es/gestures/drag/use-drag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-drag.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/gestures/drag/use-drag.js"],"sourcesContent":["import { __assign } from 'tslib';\nimport { useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.js';\nimport { VisualElementDragControls } from './VisualElementDragControls.js';\nimport { useConstant } from '../../utils/use-constant.js';\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 transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n    var dragControls = useConstant(function () {\n        return new VisualElementDragControls({\n            visualElement: visualElement,\n        });\n    });\n    dragControls.setProps(__assign(__assign({}, props), { transformPagePoint: transformPagePoint }));\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]);\n    // Mount the drag controls with the visualElement\n    useEffect(function () { return dragControls.mount(visualElement); }, []);\n}\n\nexport { useDrag };\n"],"names":["props","groupDragControls","dragControls","visualElement","transformPagePoint","useContext","MotionConfigContext","useConstant","VisualElementDragControls","setProps","__assign","useEffect","subscribe","mount"],"mappings":"iSAWA,SAAiBA,GACb,IAAIC,EAAoBD,EAAME,aAAcC,EAAgBH,EAAMG,cAC9DC,EAAqBC,EAAAA,WAAWC,EAAmBA,qBAAEF,mBACrDF,EAAeK,EAAAA,aAAY,WAC3B,OAAO,IAAIC,EAAAA,0BAA0B,CACjCL,cAAeA,OAGvBD,EAAaO,SAASC,WAASA,EAAAA,SAAS,GAAIV,GAAQ,CAAEI,mBAAoBA,KAG1EO,EAAAA,WAAU,WAAc,OAAOV,GAAqBA,EAAkBW,UAAUV,KAAkB,CAACA,IAEnGS,aAAU,WAAc,OAAOT,EAAaW,MAAMV,KAAmB"}

package/build/node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("../../../../../../tslib/tslib.es6.js"),i=require("../../../../../../popmotion/dist/es/utils/mix.js");function n(t,n,r){var o=n.min,e=n.max;return void 0!==o&&t<o?t=r?i.mix(o,t,r.min):Math.max(t,o):void 0!==e&&t>e&&(t=r?i.mix(e,t,r.max):Math.min(t,e)),t}function r(t,i,n){return{min:void 0!==i?t.min+i:void 0,max:void 0!==n?t.max+n-(t.max-t.min):void 0}}function o(i,n){var r,o=n.min-i.min,e=n.max-i.max;return n.max-n.min<i.max-i.min&&(o=(r=t.__read([e,o],2))[0],e=r[1]),{min:i.min+o,max:i.min+e}}function e(t,i,n){return{min:a(t,i),max:a(t,n)}}function a(t,i){var n;return"number"==typeof t?t:null!==(n=t[i])&&void 0!==n?n:0}exports.applyConstraints=n,exports.calcConstrainedMinPoint=function(t,i,r,o,e){var a=t-i*r;return o?n(a,o,e):a},exports.calcPositionFromProgress=function(t,n,r){var o=t.max-t.min,e=i.mix(n.min,n.max-o,r);return{min:e,max:e+o}},exports.calcRelativeAxisConstraints=r,exports.calcRelativeConstraints=function(t,i){var n=i.top,o=i.left,e=i.bottom,a=i.right;return{x:r(t.x,o,a),y:r(t.y,n,e)}},exports.calcViewportAxisConstraints=o,exports.calcViewportConstraints=function(t,i){return{x:o(t.x,i.x),y:o(t.y,i.y)}},exports.defaultElastic=.35,exports.rebaseAxisConstraints=function(t,i){var n={};return void 0!==i.min&&(n.min=i.min-t.min),void 0!==i.max&&(n.max=i.max-t.min),n},exports.resolveAxisElastic=e,exports.resolveDragElastic=function(t){return!1===t?t=0:!0===t&&(t=.35),{x:e(t,"left","right"),y:e(t,"top","bottom")}},exports.resolvePointElastic=a;
+//# sourceMappingURL=constraints.js.map

package/build/node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js"],"sourcesContent":["import { __read } from 'tslib';\nimport { mix } from 'popmotion';\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 * Calculates a min projection point based on a pointer, pointer progress\n * within the drag target, and constraints.\n *\n * For instance if an element was 100px width, we were dragging from 0.25\n * along this axis, the pointer is at 200px, and there were no constraints,\n * we would calculate a min projection point of 175px.\n */\nfunction calcConstrainedMinPoint(point, length, progress, constraints, elastic) {\n    // Calculate a min point for this axis and apply it to the current pointer\n    var min = point - length * progress;\n    return constraints ? applyConstraints(min, constraints, elastic) : min;\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 {\n        min: layoutAxis.min + min,\n        max: layoutAxis.min + max,\n    };\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 the an axis position based on two axes and a progress value.\n */\nfunction calcPositionFromProgress(axis, constraints, progress) {\n    var axisLength = axis.max - axis.min;\n    var min = mix(constraints.min, constraints.max - axisLength, progress);\n    return { min: min, max: min + axisLength };\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 === 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, calcConstrainedMinPoint, calcPositionFromProgress, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n"],"names":["applyConstraints","point","_a","elastic","min","max","undefined","mix","Math","calcRelativeAxisConstraints","axis","calcViewportAxisConstraints","layoutAxis","constraintsAxis","__read","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","length","progress","constraints","axisLength","layoutBox","top","left","bottom","right","x","y","constraintsBox","layout","relativeConstraints"],"mappings":"wLAQA,SAASA,EAAiBC,EAAOC,EAAIC,GACjC,IAAIC,EAAMF,EAAGE,IAAKC,EAAMH,EAAGG,IAS3B,YARYC,IAARF,GAAqBH,EAAQG,EAE7BH,EAAQE,EAAUI,MAAIH,EAAKH,EAAOE,EAAQC,KAAOI,KAAKH,IAAIJ,EAAOG,QAEpDE,IAARD,GAAqBJ,EAAQI,IAElCJ,EAAQE,EAAUI,MAAIF,EAAKJ,EAAOE,EAAQE,KAAOG,KAAKJ,IAAIH,EAAOI,IAE9DJ,EAoBX,SAASQ,EAA4BC,EAAMN,EAAKC,GAC5C,MAAO,CACHD,SAAaE,IAARF,EAAoBM,EAAKN,IAAMA,OAAME,EAC1CD,SAAaC,IAARD,EACCK,EAAKL,IAAMA,GAAOK,EAAKL,IAAMK,EAAKN,UAClCE,GAiBd,SAASK,EAA4BC,EAAYC,GAC7C,IAAIX,EACAE,EAAMS,EAAgBT,IAAMQ,EAAWR,IACvCC,EAAMQ,EAAgBR,IAAMO,EAAWP,IAO3C,OAJIQ,EAAgBR,IAAMQ,EAAgBT,IACtCQ,EAAWP,IAAMO,EAAWR,MACAA,GAA5BF,EAAKY,EAAAA,OAAO,CAACT,EAAKD,GAAM,IAAa,GAAIC,EAAMH,EAAG,IAE/C,CACHE,IAAKQ,EAAWR,IAAMA,EACtBC,IAAKO,EAAWR,IAAMC,GAiD9B,SAASU,EAAmBC,EAAaC,EAAUC,GAC/C,MAAO,CACHd,IAAKe,EAAoBH,EAAaC,GACtCZ,IAAKc,EAAoBH,EAAaE,IAG9C,SAASC,EAAoBH,EAAaI,GACtC,IAAIlB,EACJ,MAA8B,iBAAhBc,EACRA,EAC8B,QAA7Bd,EAAKc,EAAYI,UAA2B,IAAPlB,EAAgBA,EAAK,6DAvGrE,SAAiCD,EAAOoB,EAAQC,EAAUC,EAAapB,GAEnE,IAAIC,EAAMH,EAAQoB,EAASC,EAC3B,OAAOC,EAAcvB,EAAiBI,EAAKmB,EAAapB,GAAWC,oCAwDvE,SAAkCM,EAAMa,EAAaD,GACjD,IAAIE,EAAad,EAAKL,IAAMK,EAAKN,IAC7BA,EAAMG,EAAGA,IAACgB,EAAYnB,IAAKmB,EAAYlB,IAAMmB,EAAYF,GAC7D,MAAO,CAAElB,IAAKA,EAAKC,IAAKD,EAAMoB,0EAxClC,SAAiCC,EAAWvB,GACxC,IAAIwB,EAAMxB,EAAGwB,IAAKC,EAAOzB,EAAGyB,KAAMC,EAAS1B,EAAG0B,OAAQC,EAAQ3B,EAAG2B,MACjE,MAAO,CACHC,EAAGrB,EAA4BgB,EAAUK,EAAGH,EAAME,GAClDE,EAAGtB,EAA4BgB,EAAUM,EAAGL,EAAKE,2EAwBzD,SAAiCH,EAAWO,GACxC,MAAO,CACHF,EAAGnB,EAA4Bc,EAAUK,EAAGE,EAAeF,GAC3DC,EAAGpB,EAA4Bc,EAAUM,EAAGC,EAAeD,4BAwB9C,kCAVrB,SAA+BE,EAAQV,GACnC,IAAIW,EAAsB,GAO1B,YANwB5B,IAApBiB,EAAYnB,MACZ8B,EAAoB9B,IAAMmB,EAAYnB,IAAM6B,EAAO7B,UAE/BE,IAApBiB,EAAYlB,MACZ6B,EAAoB7B,IAAMkB,EAAYlB,IAAM4B,EAAO7B,KAEhD8B,2DAMX,SAA4BlB,GAOxB,OANoB,IAAhBA,EACAA,EAAc,GAEO,IAAhBA,IACLA,EATa,KAWV,CACHc,EAAGf,EAAmBC,EAAa,OAAQ,SAC3Ce,EAAGhB,EAAmBC,EAAa,MAAO"}

package/build/node_modules/framer-motion/dist/es/gestures/drag/utils/lock.js

@@ -0,0 +1,2 @@
+"use strict";function r(r){var e=null;return function(){return null===e&&(e=r,function(){e=null})}}Object.defineProperty(exports,"__esModule",{value:!0});var e=r("dragHorizontal"),t=r("dragVertical");function n(r){var n=!1;if("y"===r)n=t();else if("x"===r)n=e();else{var o=e(),u=t();o&&u?n=function(){o(),u()}:(o&&o(),u&&u())}return n}exports.createLock=r,exports.getGlobalLock=n,exports.isDragActive=function(){var r=n(!0);return!r||(r(),!1)};
+//# sourceMappingURL=lock.js.map

package/build/node_modules/framer-motion/dist/es/gestures/drag/utils/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/gestures/drag/utils/lock.js"],"sourcesContent":["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"],"names":["createLock","name","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","openGestureLock"],"mappings":"aAAA,SAASA,EAAWC,GAChB,IAAIC,EAAO,KACX,OAAO,WAIH,OAAa,OAATA,IACAA,EAAOD,EAJI,WACXC,EAAO,+DASnB,IAAIC,EAAuBH,EAAW,kBAClCI,EAAqBJ,EAAW,gBACpC,SAASK,EAAcC,GACnB,IAAIJ,GAAO,EACX,GAAa,MAATI,EACAJ,EAAOE,SAEN,GAAa,MAATE,EACLJ,EAAOC,QAEN,CACD,IAAII,EAAmBJ,IACnBK,EAAiBJ,IACjBG,GAAoBC,EACpBN,EAAO,WACHK,IACAC,MAKAD,GACAA,IACAC,GACAA,KAGZ,OAAON,oEAEX,WAGI,IAAIO,EAAkBJ,GAAc,GACpC,OAAKI,IAELA,KACO"}

package/build/node_modules/framer-motion/dist/es/gestures/use-focus-gesture.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../render/utils/types.js"),t=require("../events/use-dom-event.js");exports.useFocusGesture=function(i){var n=i.whileFocus,o=i.visualElement;t.useDomEvent(o,"focus",n?function(){var t;null===(t=o.animationState)||void 0===t||t.setActive(e.AnimationType.Focus,!0)}:void 0),t.useDomEvent(o,"blur",n?function(){var t;null===(t=o.animationState)||void 0===t||t.setActive(e.AnimationType.Focus,!1)}:void 0)};
+//# sourceMappingURL=use-focus-gesture.js.map

package/build/node_modules/framer-motion/dist/es/gestures/use-focus-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-gesture.js","sources":["../../../../../../node_modules/framer-motion/dist/es/gestures/use-focus-gesture.js"],"sourcesContent":["import { AnimationType } from '../render/utils/types.js';\nimport { useDomEvent } from '../events/use-dom-event.js';\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"],"names":["_a","whileFocus","visualElement","useDomEvent","animationState","setActive","AnimationType","Focus","undefined"],"mappings":"8KASA,SAAyBA,GACrB,IAAIC,EAAaD,EAAGC,WAAYC,EAAgBF,EAAGE,cASnDC,EAAWA,YAACD,EAAe,QAASD,EARtB,WACV,IAAID,EACoC,QAAvCA,EAAKE,EAAcE,sBAAmC,IAAPJ,GAAyBA,EAAGK,UAAUC,EAAaA,cAACC,OAAO,SAMpDC,GAC3DL,EAAWA,YAACD,EAAe,OAAQD,EALtB,WACT,IAAID,EACoC,QAAvCA,EAAKE,EAAcE,sBAAmC,IAAPJ,GAAyBA,EAAGK,UAAUC,EAAaA,cAACC,OAAO,SAGtDC"}

package/build/node_modules/framer-motion/dist/es/gestures/use-hover-gesture.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./utils/event-type.js"),t=require("../render/utils/types.js"),r=require("../events/use-pointer-event.js"),n=require("./drag/utils/lock.js");function i(r,i,o){return function(s,u){var v;e.isMouseEvent(s)&&!n.isDragActive()&&(null==o||o(s,u),null===(v=r.animationState)||void 0===v||v.setActive(t.AnimationType.Hover,i))}}exports.useHoverGesture=function(e){var t=e.onHoverStart,n=e.onHoverEnd,o=e.whileHover,s=e.visualElement;r.usePointerEvent(s,"pointerenter",t||o?i(s,!0,t):void 0),r.usePointerEvent(s,"pointerleave",n||o?i(s,!1,n):void 0)};
+//# sourceMappingURL=use-hover-gesture.js.map

package/build/node_modules/framer-motion/dist/es/gestures/use-hover-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hover-gesture.js","sources":["../../../../../../node_modules/framer-motion/dist/es/gestures/use-hover-gesture.js"],"sourcesContent":["import { isMouseEvent } from './utils/event-type.js';\nimport { AnimationType } from '../render/utils/types.js';\nimport { usePointerEvent } from '../events/use-pointer-event.js';\nimport { isDragActive } from './drag/utils/lock.js';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\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"],"names":["createHoverEvent","visualElement","isActive","callback","event","info","_a","isMouseEvent","isDragActive","animationState","setActive","AnimationType","Hover","onHoverStart","onHoverEnd","whileHover","usePointerEvent","undefined"],"mappings":"+NAKA,SAASA,EAAiBC,EAAeC,EAAUC,GAC/C,OAAO,SAAUC,EAAOC,GACpB,IAAIC,EACCC,EAAYA,aAACH,KAAUI,mBAE5BL,MAAAA,GAAoDA,EAASC,EAAOC,GAC5B,QAAvCC,EAAKL,EAAcQ,sBAAmC,IAAPH,GAAyBA,EAAGI,UAAUC,EAAaA,cAACC,MAAOV,6BAGnH,SAAyBI,GACrB,IAAIO,EAAeP,EAAGO,aAAcC,EAAaR,EAAGQ,WAAYC,EAAaT,EAAGS,WAAYd,EAAgBK,EAAGL,cAC/Ge,EAAAA,gBAAgBf,EAAe,eAAgBY,GAAgBE,EACzDf,EAAiBC,GAAe,EAAMY,QACtCI,GACND,EAAAA,gBAAgBf,EAAe,eAAgBa,GAAcC,EACvDf,EAAiBC,GAAe,EAAOa,QACvCG"}

package/build/node_modules/framer-motion/dist/es/gestures/use-pan-gesture.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("react"),e=require("../context/MotionConfigContext.js"),t=require("../utils/use-unmount-effect.js"),r=require("../events/use-pointer-event.js"),o=require("./PanSession.js");exports.usePanGesture=function(u){var s=u.onPan,i=u.onPanStart,a=u.onPanEnd,c=u.onPanSessionStart,f=u.visualElement,P=s||i||a||c,l=n.useRef(null),d=n.useContext(e.MotionConfigContext).transformPagePoint,v={onSessionStart:c,onStart:i,onMove:s,onEnd:function(n,e){l.current=null,a&&a(n,e)}};n.useEffect((function(){null!==l.current&&l.current.updateHandlers(v)})),r.usePointerEvent(f,"pointerdown",P&&function(n){l.current=new o.PanSession(n,v,{transformPagePoint:d})}),t.useUnmountEffect((function(){return l.current&&l.current.end()}))};
+//# sourceMappingURL=use-pan-gesture.js.map

package/build/node_modules/framer-motion/dist/es/gestures/use-pan-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pan-gesture.js","sources":["../../../../../../node_modules/framer-motion/dist/es/gestures/use-pan-gesture.js"],"sourcesContent":["import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.js';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.js';\nimport { usePointerEvent } from '../events/use-pointer-event.js';\nimport { PanSession } from './PanSession.js';\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"],"names":["_a","onPan","onPanStart","onPanEnd","onPanSessionStart","visualElement","hasPanEvents","panSession","useRef","transformPagePoint","useContext","MotionConfigContext","handlers","onSessionStart","onStart","onMove","onEnd","event","info","current","useEffect","updateHandlers","usePointerEvent","PanSession","useUnmountEffect","end"],"mappings":"qRAkBA,SAAuBA,GACnB,IAAIC,EAAQD,EAAGC,MAAOC,EAAaF,EAAGE,WAAYC,EAAWH,EAAGG,SAAUC,EAAoBJ,EAAGI,kBAAmBC,EAAgBL,EAAGK,cACnIC,EAAeL,GAASC,GAAcC,GAAYC,EAClDG,EAAaC,SAAO,MACpBC,EAAqBC,EAAAA,WAAWC,EAAmBA,qBAAEF,mBACrDG,EAAW,CACXC,eAAgBT,EAChBU,QAASZ,EACTa,OAAQd,EACRe,MAAO,SAAUC,EAAOC,GACpBX,EAAWY,QAAU,KACrBhB,GAAYA,EAASc,EAAOC,KAGpCE,EAAAA,WAAU,WACqB,OAAvBb,EAAWY,SACXZ,EAAWY,QAAQE,eAAeT,MAQ1CU,EAAAA,gBAAgBjB,EAAe,cAAeC,GAL9C,SAAuBW,GACnBV,EAAWY,QAAU,IAAII,aAAWN,EAAOL,EAAU,CACjDH,mBAAoBA,MAI5Be,oBAAiB,WAAc,OAAOjB,EAAWY,SAAWZ,EAAWY,QAAQM"}

package/build/node_modules/framer-motion/dist/es/gestures/use-tap-gesture.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),n=require("./utils/is-node-or-child.js"),t=require("../events/use-pointer-event.js"),i=require("../utils/use-unmount-effect.js"),r=require("../render/utils/types.js"),u=require("./drag/utils/lock.js"),o=require("../../../../popmotion/dist/es/utils/pipe.js");exports.useTapGesture=function(l){var s=l.onTap,a=l.onTapStart,c=l.onTapCancel,p=l.whileTap,d=l.visualElement,v=s||a||c||p,f=e.useRef(!1),T=e.useRef(null);function m(){var e;null===(e=T.current)||void 0===e||e.call(T),T.current=null}function j(){var e;return m(),f.current=!1,null===(e=d.animationState)||void 0===e||e.setActive(r.AnimationType.Tap,!1),!u.isDragActive()}function q(e,t){j()&&(n.isNodeOrChild(d.getInstance(),e.target)?null==s||s(e,t):null==c||c(e,t))}function w(e,n){j()&&(null==c||c(e,n))}t.usePointerEvent(d,"pointerdown",v?function(e,n){var i;m(),f.current||(f.current=!0,T.current=o.pipe(t.addPointerEvent(window,"pointerup",q),t.addPointerEvent(window,"pointercancel",w)),null==a||a(e,n),null===(i=d.animationState)||void 0===i||i.setActive(r.AnimationType.Tap,!0))}:void 0),i.useUnmountEffect(m)};
+//# sourceMappingURL=use-tap-gesture.js.map

package/build/node_modules/framer-motion/dist/es/gestures/use-tap-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tap-gesture.js","sources":["../../../../../../node_modules/framer-motion/dist/es/gestures/use-tap-gesture.js"],"sourcesContent":["import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.js';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.js';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.js';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.js';\nimport { isDragActive } from './drag/utils/lock.js';\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        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n"],"names":["_a","onTap","onTapStart","onTapCancel","whileTap","visualElement","hasPressListeners","isPressing","useRef","cancelPointerEndListeners","removePointerEndListener","current","call","checkPointerEnd","animationState","setActive","AnimationType","Tap","isDragActive","onPointerUp","event","info","isNodeOrChild","getInstance","target","onPointerCancel","usePointerEvent","pipe","addPointerEvent","window","undefined","useUnmountEffect"],"mappings":"mXAYA,SAAuBA,GACnB,IAAIC,EAAQD,EAAGC,MAAOC,EAAaF,EAAGE,WAAYC,EAAcH,EAAGG,YAAaC,EAAWJ,EAAGI,SAAUC,EAAgBL,EAAGK,cACvHC,EAAoBL,GAASC,GAAcC,GAAeC,EAC1DG,EAAaC,UAAO,GACpBC,EAA4BD,SAAO,MACvC,SAASE,IACL,IAAIV,EACyC,QAA5CA,EAAKS,EAA0BE,eAA4B,IAAPX,GAAyBA,EAAGY,KAAKH,GACtFA,EAA0BE,QAAU,KAExC,SAASE,IACL,IAAIb,EAIJ,OAHAU,IACAH,EAAWI,SAAU,EACmB,QAAvCX,EAAKK,EAAcS,sBAAmC,IAAPd,GAAyBA,EAAGe,UAAUC,EAAaA,cAACC,KAAK,IACjGC,EAAYA,eAExB,SAASC,EAAYC,EAAOC,GACnBR,MAMJS,EAAaA,cAACjB,EAAckB,cAAeH,EAAMI,QAE5CvB,MAAAA,GAA8CA,EAAMmB,EAAOC,GAD3DlB,MAAAA,GAA0DA,EAAYiB,EAAOC,IAGvF,SAASI,EAAgBL,EAAOC,GACvBR,MAELV,MAAAA,GAA0DA,EAAYiB,EAAOC,IAYjFK,EAAeA,gBAACrB,EAAe,cAAeC,EAV9C,SAAuBc,EAAOC,GAC1B,IAAIrB,EACJU,IACIH,EAAWI,UAEfJ,EAAWI,SAAU,EACrBF,EAA0BE,QAAUgB,EAAAA,KAAKC,EAAeA,gBAACC,OAAQ,YAAaV,GAAcS,EAAeA,gBAACC,OAAQ,gBAAiBJ,IACrIvB,MAAAA,GAAwDA,EAAWkB,EAAOC,GAClC,QAAvCrB,EAAKK,EAAcS,sBAAmC,IAAPd,GAAyBA,EAAGe,UAAUC,EAAaA,cAACC,KAAK,UAE3Ba,GAClFC,EAAgBA,iBAACrB"}

package/build/node_modules/framer-motion/dist/es/gestures/utils/event-type.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.isMouseEvent=function(e){return"undefined"!=typeof PointerEvent&&e instanceof PointerEvent?!("mouse"!==e.pointerType):e instanceof MouseEvent},exports.isTouchEvent=function(e){return!!e.touches};
+//# sourceMappingURL=event-type.js.map

package/build/node_modules/framer-motion/dist/es/gestures/utils/event-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-type.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/gestures/utils/event-type.js"],"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"],"names":["event","PointerEvent","pointerType","MouseEvent","touches"],"mappings":"yFAAA,SAAsBA,GAElB,MAA4B,oBAAjBC,cAAgCD,aAAiBC,eACxB,UAAtBD,EAAME,aAEbF,aAAiBG,iCAE5B,SAAsBH,GAElB,QADmBA,EAAMI"}

package/build/node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=function(r,t){return!!t&&(r===t||e(r,t.parentElement))};exports.isNodeOrChild=e;
+//# sourceMappingURL=is-node-or-child.js.map

package/build/node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-node-or-child.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.js"],"sourcesContent":["/**\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"],"names":["isNodeOrChild","parent","child","parentElement"],"mappings":"oEAOG,IAACA,EAAgB,SAAUC,EAAQC,GAClC,QAAKA,IAGID,IAAWC,GAITF,EAAcC,EAAQC,EAAMC"}

package/build/node_modules/framer-motion/dist/es/motion/features/animations.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../tslib/tslib.es6.js"),t=require("react"),n=require("../../animation/utils/is-animation-controls.js"),i=require("../../components/AnimatePresence/use-presence.js"),s=require("../../context/PresenceContext.js"),r=require("../../render/utils/animation-state.js"),o=require("../../render/utils/types.js"),a=require("../utils/make-renderless-component.js"),u={animation:a.makeRenderlessComponent((function(e){var i=e.visualElement,s=e.animate;i.animationState||(i.animationState=r.createAnimationState(i)),n.isAnimationControls(s)&&t.useEffect((function(){return s.subscribe(i)}),[s])})),exit:a.makeRenderlessComponent((function(n){var r=n.custom,a=n.visualElement,u=e.__read(i.usePresence(),2),l=u[0],m=u[1],c=t.useContext(s.PresenceContext);t.useEffect((function(){var e,t,n=null===(e=a.animationState)||void 0===e?void 0:e.setActive(o.AnimationType.Exit,!l,{custom:null!==(t=null==c?void 0:c.custom)&&void 0!==t?t:r});!l&&(null==n||n.then(m))}),[l])}))};exports.animations=u;
+//# sourceMappingURL=animations.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/animations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/features/animations.js"],"sourcesContent":["import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.js';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.js';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { createAnimationState } from '../../render/utils/animation-state.js';\nimport { AnimationType } from '../../render/utils/types.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\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], onExitComplete = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\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(onExitComplete));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n"],"names":["animations","animation","makeRenderlessComponent","_a","visualElement","animate","animationState","createAnimationState","isAnimationControls","useEffect","subscribe","exit","props","custom","__read","usePresence","isPresent","onExitComplete","presenceContext","useContext","PresenceContext","_b","setActive","AnimationType","Exit","then"],"mappings":"icASIA,EAAa,CACbC,UAAWC,EAAAA,yBAAwB,SAAUC,GACzC,IAAIC,EAAgBD,EAAGC,cAAeC,EAAUF,EAAGE,QAMnDD,EAAcE,iBAAmBF,EAAcE,eAAiBC,EAAoBA,qBAACH,IAIjFI,EAAAA,oBAAoBH,IACpBI,aAAU,WAAc,OAAOJ,EAAQK,UAAUN,KAAmB,CAACC,OAG7EM,KAAMT,EAAAA,yBAAwB,SAAUU,GACpC,IAAIC,EAASD,EAAMC,OAAQT,EAAgBQ,EAAMR,cAC7CD,EAAKW,EAAMA,OAACC,gBAAe,GAAIC,EAAYb,EAAG,GAAIc,EAAiBd,EAAG,GACtEe,EAAkBC,aAAWC,EAAAA,iBACjCX,EAAAA,WAAU,WACN,IAAIN,EAAIkB,EACJpB,EAAoD,QAAvCE,EAAKC,EAAcE,sBAAmC,IAAPH,OAAgB,EAASA,EAAGmB,UAAUC,EAAAA,cAAcC,MAAOR,EAAW,CAAEH,OAA4G,QAAnGQ,EAAKH,MAAAA,OAAyD,EAASA,EAAgBL,cAA2B,IAAPQ,EAAgBA,EAAKR,KAChRG,IAAcf,MAAAA,GAAsDA,EAAUwB,KAAKR,MACrF,CAACD"}

package/build/node_modules/framer-motion/dist/es/motion/features/definitions.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var a=function(a){return{isEnabled:function(n){return a.some((function(a){return!!n[a]}))}}},n={measureLayout:a(["layout","layoutId","drag","_layoutResetTransform"]),animation:a(["animate","exit","variants","whileHover","whileTap","whileFocus","whileDrag"]),exit:a(["exit"]),drag:a(["drag","dragControls"]),focus:a(["whileFocus"]),hover:a(["whileHover","onHoverStart","onHoverEnd"]),tap:a(["whileTap","onTap","onTapStart","onTapCancel"]),pan:a(["onPan","onPanStart","onPanSessionStart","onPanEnd"]),layoutAnimation:a(["layout","layoutId"])};exports.featureDefinitions=n,exports.loadFeatures=function(a){for(var o in a){var e=a[o];null!==e&&(n[o].Component=e)}};
+//# sourceMappingURL=definitions.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/features/definitions.js"],"sourcesContent":["var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\n        \"layout\",\n        \"layoutId\",\n        \"drag\",\n        \"_layoutResetTransform\",\n    ]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    layoutAnimation: createDefinition([\"layout\", \"layoutId\"]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        var Component = features[key];\n        if (Component !== null)\n            featureDefinitions[key].Component = Component;\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n"],"names":["createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","layoutAnimation","features","key","Component"],"mappings":"oEAAA,IAAIA,EAAmB,SAAUC,GAAa,MAAQ,CAClDC,UAAW,SAAUC,GAAS,OAAOF,EAAUG,MAAK,SAAUC,GAAQ,QAASF,EAAME,SAErFC,EAAqB,CACrBC,cAAeP,EAAiB,CAC5B,SACA,WACA,OACA,0BAEJQ,UAAWR,EAAiB,CACxB,UACA,OACA,WACA,aACA,WACA,aACA,cAEJS,KAAMT,EAAiB,CAAC,SACxBU,KAAMV,EAAiB,CAAC,OAAQ,iBAChCW,MAAOX,EAAiB,CAAC,eACzBY,MAAOZ,EAAiB,CAAC,aAAc,eAAgB,eACvDa,IAAKb,EAAiB,CAAC,WAAY,QAAS,aAAc,gBAC1Dc,IAAKd,EAAiB,CAClB,QACA,aACA,oBACA,aAEJe,gBAAiBf,EAAiB,CAAC,SAAU,gEAEjD,SAAsBgB,GAClB,IAAK,IAAIC,KAAOD,EAAU,CACtB,IAAIE,EAAYF,EAASC,GACP,OAAdC,IACAZ,EAAmBW,GAAKC,UAAYA"}

package/build/node_modules/framer-motion/dist/es/motion/features/drag.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../gestures/drag/use-drag.js"),r=require("../../gestures/use-pan-gesture.js"),s=require("../utils/make-renderless-component.js"),u={pan:s.makeRenderlessComponent(r.usePanGesture),drag:s.makeRenderlessComponent(e.useDrag)};exports.drag=u;
+//# sourceMappingURL=drag.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/drag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drag.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/features/drag.js"],"sourcesContent":["import { useDrag } from '../../gestures/drag/use-drag.js';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n"],"names":["drag","pan","makeRenderlessComponent","usePanGesture","useDrag"],"mappings":"uNAIIA,EAAO,CACPC,IAAKC,EAAuBA,wBAACC,iBAC7BH,KAAME,EAAuBA,wBAACE"}

package/build/node_modules/framer-motion/dist/es/motion/features/gestures.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../gestures/use-focus-gesture.js"),s=require("../../gestures/use-hover-gesture.js"),r=require("../../gestures/use-tap-gesture.js"),u=require("../utils/make-renderless-component.js"),t={tap:u.makeRenderlessComponent(r.useTapGesture),focus:u.makeRenderlessComponent(e.useFocusGesture),hover:u.makeRenderlessComponent(s.useHoverGesture)};exports.gestureAnimations=t;
+//# sourceMappingURL=gestures.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/gestures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gestures.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/features/gestures.js"],"sourcesContent":["import { useFocusGesture } from '../../gestures/use-focus-gesture.js';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.js';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\n\nvar gestureAnimations = {\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n"],"names":["gestureAnimations","tap","makeRenderlessComponent","useTapGesture","focus","useFocusGesture","hover","useHoverGesture"],"mappings":"4QAKIA,EAAoB,CACpBC,IAAKC,EAAuBA,wBAACC,iBAC7BC,MAAOF,EAAuBA,wBAACG,mBAC/BC,MAAOJ,EAAuBA,wBAACK"}

package/build/node_modules/framer-motion/dist/es/motion/features/layout/Animate.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../../tslib/tslib.es6.js"),t=require("react"),i=require("../../../utils/each-axis.js"),n=require("../../../animation/utils/transitions.js"),r=require("./utils.js"),o=require("../../../components/AnimateSharedLayout/types.js"),a=require("../../../components/AnimatePresence/use-presence.js"),s=require("../../../utils/geometry/index.js"),u=require("../../../render/dom/projection/scale-correction.js"),c=require("../../../render/dom/projection/default-scale-correctors.js");function l(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(i){if("default"!==i){var n=Object.getOwnPropertyDescriptor(e,i);Object.defineProperty(t,i,n.get?n:{enumerable:!0,get:function(){return e[i]}})}})),t.default=e,Object.freeze(t)}var m=l(t),v=function(t){function a(){var n=null!==t&&t.apply(this,arguments)||this;return n.frameTarget=s.axisBox(),n.currentAnimationTarget=s.axisBox(),n.isAnimating={x:!1,y:!1},n.stopAxisAnimation={x:void 0,y:void 0},n.isAnimatingTree=!1,n.animate=function(t,a,s){void 0===s&&(s={});var u=s.originBox,c=s.targetBox,l=s.visibilityAction,m=s.shouldStackAnimate,v=s.onComplete,f=s.prevParent,x=e.__rest(s,["originBox","targetBox","visibilityAction","shouldStackAnimate","onComplete","prevParent"]),A=n.props,d=A.visualElement,g=A.layout;if(!1===m)return n.isAnimatingTree=!1,n.safeToRemove();if(!n.isAnimatingTree||!0===m){m&&(n.isAnimatingTree=!0),a=u||a,t=c||t;var h=!1,j=d.getProjectionParent();if(j){var T=j.prevViewportBox,P=j.getLayoutState().layout;f&&(c&&(P=f.getLayoutState().layout),u&&!r.checkIfParentHasChanged(f,j)&&f.prevViewportBox&&(T=f.prevViewportBox)),T&&y(f,u,c)&&(h=!0,a=r.calcRelativeOffset(T,a),t=r.calcRelativeOffset(P,t))}var b=p(a,t),_=i.eachAxis((function(i){var r,s;if("position"===g){var u=t[i].max-t[i].min;a[i].max=a[i].min+u}if(!d.projection.isTargetLocked)return void 0===l?b?n.animateAxis(i,t[i],a[i],e.__assign(e.__assign({},x),{isRelative:h})):(null===(s=(r=n.stopAxisAnimation)[i])||void 0===s||s.call(r),d.setProjectionTargetAxis(i,t[i].min,t[i].max,h)):void d.setVisibility(l===o.VisibilityAction.Show)}));return d.syncRender(),Promise.all(_).then((function(){n.isAnimatingTree=!1,v&&v(),d.notifyLayoutAnimationComplete()}))}},n}return e.__extends(a,t),a.prototype.componentDidMount=function(){var e=this,t=this.props.visualElement;t.animateMotionValue=n.startAnimation,t.enableLayoutProjection(),this.unsubLayoutReady=t.onLayoutUpdate(this.animate),t.layoutSafeToRemove=function(){return e.safeToRemove()},u.addScaleCorrection(c.defaultScaleCorrectors)},a.prototype.componentWillUnmount=function(){var e=this;this.unsubLayoutReady(),i.eachAxis((function(t){var i,n;return null===(n=(i=e.stopAxisAnimation)[t])||void 0===n?void 0:n.call(i)}))},a.prototype.animateAxis=function(e,t,i,o){var a,s,u=this,c=void 0===o?{}:o,l=c.transition,m=c.isRelative;if(!this.isAnimating[e]||!A(t,this.currentAnimationTarget[e])){null===(s=(a=this.stopAxisAnimation)[e])||void 0===s||s.call(a),this.isAnimating[e]=!0;var v=this.props.visualElement,p=this.frameTarget[e],f=v.getProjectionAnimationProgress()[e];f.clearListeners(),f.set(0),f.set(0);var x=function(){var n=f.get()/1e3;r.tweenAxis(p,i,t,n),v.setProjectionTargetAxis(e,p.min,p.max,m)};x();var y=f.onChange(x);this.stopAxisAnimation[e]=function(){u.isAnimating[e]=!1,f.stop(),y()},this.currentAnimationTarget[e]=t;var g=l||v.getDefaultTransition()||d;return n.startAnimation("x"===e?"layoutX":"layoutY",f,1e3,g&&n.getValueTransition(g,"layout")).then(this.stopAxisAnimation[e])}},a.prototype.safeToRemove=function(){var e,t;null===(t=(e=this.props).safeToRemove)||void 0===t||t.call(e)},a.prototype.render=function(){return null},a}(m.Component);function p(e,t){return!(x(e)||x(t)||A(e.x,t.x)&&A(e.y,t.y))}var f={min:0,max:0};function x(e){return A(e.x,f)&&A(e.y,f)}function A(e,t){return e.min===t.min&&e.max===t.max}var d={duration:.45,ease:[.4,0,.1,1]};function y(e,t,i){return e||!e&&!(t||i)}exports.AnimateLayoutContextProvider=function(t){var i=e.__read(a.usePresence(),2)[1];return m.createElement(v,e.__assign({},t,{safeToRemove:i}))};
+//# sourceMappingURL=Animate.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/layout/Animate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Animate.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/motion/features/layout/Animate.js"],"sourcesContent":["import { __extends, __rest, __assign, __read } from 'tslib';\nimport * as React from 'react';\nimport { eachAxis } from '../../../utils/each-axis.js';\nimport { startAnimation, getValueTransition } from '../../../animation/utils/transitions.js';\nimport { checkIfParentHasChanged, calcRelativeOffset, tweenAxis } from './utils.js';\nimport { VisibilityAction } from '../../../components/AnimateSharedLayout/types.js';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.js';\nimport { axisBox } from '../../../utils/geometry/index.js';\nimport { addScaleCorrection } from '../../../render/dom/projection/scale-correction.js';\nimport { defaultScaleCorrectors } from '../../../render/dom/projection/default-scale-correctors.js';\n\nvar progressTarget = 1000;\nvar Animate = /** @class */ (function (_super) {\n    __extends(Animate, _super);\n    function Animate() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /**\n         * A mutable object that tracks the target viewport box\n         * for the current animation frame.\n         */\n        _this.frameTarget = axisBox();\n        /**\n         * The current animation target, we use this to check whether to start\n         * a new animation or continue the existing one.\n         */\n        _this.currentAnimationTarget = axisBox();\n        /**\n         * Track whether we're animating this axis.\n         */\n        _this.isAnimating = {\n            x: false,\n            y: false,\n        };\n        _this.stopAxisAnimation = {\n            x: undefined,\n            y: undefined,\n        };\n        _this.isAnimatingTree = false;\n        _this.animate = function (target, origin, _a) {\n            if (_a === void 0) { _a = {}; }\n            var originBox = _a.originBox, targetBox = _a.targetBox, visibilityAction = _a.visibilityAction, shouldStackAnimate = _a.shouldStackAnimate, onComplete = _a.onComplete, prevParent = _a.prevParent, config = __rest(_a, [\"originBox\", \"targetBox\", \"visibilityAction\", \"shouldStackAnimate\", \"onComplete\", \"prevParent\"]);\n            var _b = _this.props, visualElement = _b.visualElement, layout = _b.layout;\n            /**\n             * Early return if we've been instructed not to animate this render.\n             */\n            if (shouldStackAnimate === false) {\n                _this.isAnimatingTree = false;\n                return _this.safeToRemove();\n            }\n            /**\n             * Prioritise tree animations\n             */\n            if (_this.isAnimatingTree && shouldStackAnimate !== true) {\n                return;\n            }\n            else if (shouldStackAnimate) {\n                _this.isAnimatingTree = true;\n            }\n            /**\n             * Allow the measured origin (prev bounding box) and target (actual layout) to be\n             * overridden by the provided config.\n             */\n            origin = originBox || origin;\n            target = targetBox || target;\n            /**\n             * If this element has a projecting parent, there's an opportunity to animate\n             * it relatively to that parent rather than relatively to the viewport. This\n             * allows us to add orchestrated animations.\n             */\n            var isRelative = false;\n            var projectionParent = visualElement.getProjectionParent();\n            if (projectionParent) {\n                var prevParentViewportBox = projectionParent.prevViewportBox;\n                var parentLayout = projectionParent.getLayoutState().layout;\n                /**\n                 * If we're being provided a previous parent VisualElement by AnimateSharedLayout\n                 */\n                if (prevParent) {\n                    /**\n                     * If we've been provided an explicit target box it means we're animating back\n                     * to this previous parent. So we can make a relative box by comparing to the previous\n                     * parent's layout\n                     */\n                    if (targetBox) {\n                        parentLayout = prevParent.getLayoutState().layout;\n                    }\n                    /**\n                     * Likewise if we've been provided an explicit origin box it means we're\n                     * animating out from a different element. So we should figure out where that was\n                     * on screen relative to the new parent element.\n                     */\n                    if (originBox &&\n                        !checkIfParentHasChanged(prevParent, projectionParent) &&\n                        prevParent.prevViewportBox) {\n                        prevParentViewportBox = prevParent.prevViewportBox;\n                    }\n                }\n                if (prevParentViewportBox &&\n                    isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox)) {\n                    isRelative = true;\n                    origin = calcRelativeOffset(prevParentViewportBox, origin);\n                    target = calcRelativeOffset(parentLayout, target);\n                }\n            }\n            var boxHasMoved = hasMoved(origin, target);\n            var animations = eachAxis(function (axis) {\n                var _a, _b;\n                /**\n                 * If layout is set to \"position\", we can resize the origin box based on the target\n                 * box and only animate its position.\n                 */\n                if (layout === \"position\") {\n                    var targetLength = target[axis].max - target[axis].min;\n                    origin[axis].max = origin[axis].min + targetLength;\n                }\n                if (visualElement.projection.isTargetLocked) {\n                    return;\n                }\n                else if (visibilityAction !== undefined) {\n                    visualElement.setVisibility(visibilityAction === VisibilityAction.Show);\n                }\n                else if (boxHasMoved) {\n                    // If the box has moved, animate between it's current visual state and its\n                    // final state\n                    return _this.animateAxis(axis, target[axis], origin[axis], __assign(__assign({}, config), { isRelative: isRelative }));\n                }\n                else {\n                    (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a);\n                    // If the box has remained in the same place, immediately set the axis target\n                    // to the final desired state\n                    return visualElement.setProjectionTargetAxis(axis, target[axis].min, target[axis].max, isRelative);\n                }\n            });\n            // Force a render to ensure there's no flash of uncorrected bounding box.\n            visualElement.syncRender();\n            /**\n             * If this visualElement isn't present (ie it's been removed from the tree by the user but\n             * kept in by the tree by AnimatePresence) then call safeToRemove when all axis animations\n             * have successfully finished.\n             */\n            return Promise.all(animations).then(function () {\n                _this.isAnimatingTree = false;\n                onComplete && onComplete();\n                visualElement.notifyLayoutAnimationComplete();\n            });\n        };\n        return _this;\n    }\n    Animate.prototype.componentDidMount = function () {\n        var _this = this;\n        var visualElement = this.props.visualElement;\n        visualElement.animateMotionValue = startAnimation;\n        visualElement.enableLayoutProjection();\n        this.unsubLayoutReady = visualElement.onLayoutUpdate(this.animate);\n        visualElement.layoutSafeToRemove = function () { return _this.safeToRemove(); };\n        addScaleCorrection(defaultScaleCorrectors);\n    };\n    Animate.prototype.componentWillUnmount = function () {\n        var _this = this;\n        this.unsubLayoutReady();\n        eachAxis(function (axis) { var _a, _b; return (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a); });\n    };\n    /**\n     * TODO: This manually performs animations on the visualElement's layout progress\n     * values. It'd be preferable to amend the startLayoutAxisAnimation\n     * API to accept more custom animations like this.\n     */\n    Animate.prototype.animateAxis = function (axis, target, origin, _a) {\n        var _this = this;\n        var _b, _c;\n        var _d = _a === void 0 ? {} : _a, transition = _d.transition, isRelative = _d.isRelative;\n        /**\n         * If we're not animating to a new target, don't run this animation\n         */\n        if (this.isAnimating[axis] &&\n            axisIsEqual(target, this.currentAnimationTarget[axis])) {\n            return;\n        }\n        (_c = (_b = this.stopAxisAnimation)[axis]) === null || _c === void 0 ? void 0 : _c.call(_b);\n        this.isAnimating[axis] = true;\n        var visualElement = this.props.visualElement;\n        var frameTarget = this.frameTarget[axis];\n        var layoutProgress = visualElement.getProjectionAnimationProgress()[axis];\n        /**\n         * Set layout progress back to 0. We set it twice to hard-reset any velocity that might\n         * be re-incoporated into a subsequent spring animation.\n         */\n        layoutProgress.clearListeners();\n        layoutProgress.set(0);\n        layoutProgress.set(0);\n        /**\n         * Create an animation function to run once per frame. This will tween the visual bounding box from\n         * origin to target using the latest progress value.\n         */\n        var frame = function () {\n            // Convert the latest layoutProgress, which is a value from 0-1000, into a 0-1 progress\n            var p = layoutProgress.get() / progressTarget;\n            // Tween the axis and update the visualElement with the latest values\n            tweenAxis(frameTarget, origin, target, p);\n            visualElement.setProjectionTargetAxis(axis, frameTarget.min, frameTarget.max, isRelative);\n        };\n        // Synchronously run a frame to ensure there's no flash of the uncorrected bounding box.\n        frame();\n        // Create a function to stop animation on this specific axis\n        var unsubscribeProgress = layoutProgress.onChange(frame);\n        this.stopAxisAnimation[axis] = function () {\n            _this.isAnimating[axis] = false;\n            layoutProgress.stop();\n            unsubscribeProgress();\n        };\n        this.currentAnimationTarget[axis] = target;\n        var layoutTransition = transition ||\n            visualElement.getDefaultTransition() ||\n            defaultLayoutTransition;\n        // Start the animation on this axis\n        var animation = startAnimation(axis === \"x\" ? \"layoutX\" : \"layoutY\", layoutProgress, progressTarget, layoutTransition && getValueTransition(layoutTransition, \"layout\")).then(this.stopAxisAnimation[axis]);\n        return animation;\n    };\n    Animate.prototype.safeToRemove = function () {\n        var _a, _b;\n        (_b = (_a = this.props).safeToRemove) === null || _b === void 0 ? void 0 : _b.call(_a);\n    };\n    Animate.prototype.render = function () {\n        return null;\n    };\n    return Animate;\n}(React.Component));\nfunction AnimateLayoutContextProvider(props) {\n    var _a = __read(usePresence(), 2), safeToRemove = _a[1];\n    return React.createElement(Animate, __assign({}, props, { safeToRemove: safeToRemove }));\n}\nfunction hasMoved(a, b) {\n    return (!isZeroBox(a) &&\n        !isZeroBox(b) &&\n        (!axisIsEqual(a.x, b.x) || !axisIsEqual(a.y, b.y)));\n}\nvar zeroAxis = { min: 0, max: 0 };\nfunction isZeroBox(a) {\n    return axisIsEqual(a.x, zeroAxis) && axisIsEqual(a.y, zeroAxis);\n}\nfunction axisIsEqual(a, b) {\n    return a.min === b.min && a.max === b.max;\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox) {\n    return prevParent || (!prevParent && !(originBox || targetBox));\n}\n\nexport { AnimateLayoutContextProvider };\n"],"names":["Animate","_super","_this","apply","this","arguments","frameTarget","axisBox","currentAnimationTarget","isAnimating","x","y","stopAxisAnimation","undefined","isAnimatingTree","animate","target","origin","_a","originBox","targetBox","visibilityAction","shouldStackAnimate","onComplete","prevParent","config","__rest","_b","props","visualElement","layout","safeToRemove","isRelative","projectionParent","getProjectionParent","prevParentViewportBox","prevViewportBox","parentLayout","getLayoutState","checkIfParentHasChanged","isProvidedCorrectDataForRelativeSharedLayout","calcRelativeOffset","boxHasMoved","hasMoved","animations","eachAxis","axis","targetLength","max","min","projection","isTargetLocked","animateAxis","__assign","call","setProjectionTargetAxis","setVisibility","VisibilityAction","Show","syncRender","Promise","all","then","notifyLayoutAnimationComplete","__extends","prototype","componentDidMount","animateMotionValue","startAnimation","enableLayoutProjection","unsubLayoutReady","onLayoutUpdate","layoutSafeToRemove","addScaleCorrection","defaultScaleCorrectors","componentWillUnmount","_c","_d","transition","axisIsEqual","layoutProgress","getProjectionAnimationProgress","clearListeners","set","frame","p","get","tweenAxis","unsubscribeProgress","onChange","stop","layoutTransition","getDefaultTransition","defaultLayoutTransition","getValueTransition","render","React","Component","a","b","isZeroBox","zeroAxis","duration","ease","__read","usePresence","createElement"],"mappings":"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"}

package/build/node_modules/framer-motion/dist/es/motion/features/layout/Measure.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../../tslib/tslib.es6.js"),t=require("react"),r=require("../../../context/SharedLayoutContext.js"),o=require("../../../render/dom/projection/utils.js");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var u=n(t),a=function(t){function n(){return null!==t&&t.apply(this,arguments)||this}return e.__extends(n,t),n.prototype.componentDidMount=function(){var e=this.props,t=e.syncLayout,o=e.framerSyncLayout,n=e.visualElement;r.isSharedLayout(t)&&t.register(n),r.isSharedLayout(o)&&o.register(n),n.onUnmount((function(){r.isSharedLayout(t)&&t.remove(n),r.isSharedLayout(o)&&o.remove(n)}))},n.prototype.getSnapshotBeforeUpdate=function(){var e=this.props,t=e.syncLayout,n=e.visualElement;return r.isSharedLayout(t)?t.syncUpdate():(o.snapshotViewportBox(n),t.add(n)),null},n.prototype.componentDidUpdate=function(){var e=this.props.syncLayout;r.isSharedLayout(e)||e.flush()},n.prototype.render=function(){return null},n}(u.default.Component);exports.MeasureContextProvider=function(o){var n=t.useContext(r.SharedLayoutContext),s=t.useContext(r.FramerTreeLayoutContext);return u.default.createElement(a,e.__assign({},o,{syncLayout:n,framerSyncLayout:s}))};
+//# sourceMappingURL=Measure.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/layout/Measure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Measure.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/motion/features/layout/Measure.js"],"sourcesContent":["import { __extends, __assign } from 'tslib';\nimport React__default, { useContext } from 'react';\nimport { isSharedLayout, SharedLayoutContext, FramerTreeLayoutContext } from '../../../context/SharedLayoutContext.js';\nimport { snapshotViewportBox } from '../../../render/dom/projection/utils.js';\n\n/**\n * This component is responsible for scheduling the measuring of the motion component\n */\nvar Measure = /** @class */ (function (_super) {\n    __extends(Measure, _super);\n    function Measure() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * If this is a child of a SyncContext, register the VisualElement with it on mount.\n     */\n    Measure.prototype.componentDidMount = function () {\n        var _a = this.props, syncLayout = _a.syncLayout, framerSyncLayout = _a.framerSyncLayout, visualElement = _a.visualElement;\n        isSharedLayout(syncLayout) && syncLayout.register(visualElement);\n        isSharedLayout(framerSyncLayout) &&\n            framerSyncLayout.register(visualElement);\n        visualElement.onUnmount(function () {\n            if (isSharedLayout(syncLayout)) {\n                syncLayout.remove(visualElement);\n            }\n            if (isSharedLayout(framerSyncLayout)) {\n                framerSyncLayout.remove(visualElement);\n            }\n        });\n    };\n    /**\n     * If this is a child of a SyncContext, notify it that it needs to re-render. It will then\n     * handle the snapshotting.\n     *\n     * If it is stand-alone component, add it to the batcher.\n     */\n    Measure.prototype.getSnapshotBeforeUpdate = function () {\n        var _a = this.props, syncLayout = _a.syncLayout, visualElement = _a.visualElement;\n        if (isSharedLayout(syncLayout)) {\n            syncLayout.syncUpdate();\n        }\n        else {\n            snapshotViewportBox(visualElement);\n            syncLayout.add(visualElement);\n        }\n        return null;\n    };\n    Measure.prototype.componentDidUpdate = function () {\n        var syncLayout = this.props.syncLayout;\n        if (!isSharedLayout(syncLayout))\n            syncLayout.flush();\n    };\n    Measure.prototype.render = function () {\n        return null;\n    };\n    return Measure;\n}(React__default.Component));\nfunction MeasureContextProvider(props) {\n    var syncLayout = useContext(SharedLayoutContext);\n    var framerSyncLayout = useContext(FramerTreeLayoutContext);\n    return (React__default.createElement(Measure, __assign({}, props, { syncLayout: syncLayout, framerSyncLayout: framerSyncLayout })));\n}\n\nexport { MeasureContextProvider };\n"],"names":["Measure","_super","apply","this","arguments","__extends","prototype","componentDidMount","_a","props","syncLayout","framerSyncLayout","visualElement","isSharedLayout","register","onUnmount","remove","getSnapshotBeforeUpdate","syncUpdate","snapshotViewportBox","add","componentDidUpdate","flush","render","React__default","Component","useContext","SharedLayoutContext","FramerTreeLayoutContext","createElement","__assign"],"mappings":"0UAQIA,EAAyB,SAAUC,GAEnC,SAASD,IACL,OAAkB,OAAXC,GAAmBA,EAAOC,MAAMC,KAAMC,YAAcD,KA4C/D,OA9CAE,YAAUL,EAASC,GAOnBD,EAAQM,UAAUC,kBAAoB,WAClC,IAAIC,EAAKL,KAAKM,MAAOC,EAAaF,EAAGE,WAAYC,EAAmBH,EAAGG,iBAAkBC,EAAgBJ,EAAGI,cAC5GC,EAAAA,eAAeH,IAAeA,EAAWI,SAASF,GAClDC,EAAAA,eAAeF,IACXA,EAAiBG,SAASF,GAC9BA,EAAcG,WAAU,WAChBF,EAAAA,eAAeH,IACfA,EAAWM,OAAOJ,GAElBC,EAAAA,eAAeF,IACfA,EAAiBK,OAAOJ,OAUpCZ,EAAQM,UAAUW,wBAA0B,WACxC,IAAIT,EAAKL,KAAKM,MAAOC,EAAaF,EAAGE,WAAYE,EAAgBJ,EAAGI,cAQpE,OAPIC,EAAAA,eAAeH,GACfA,EAAWQ,cAGXC,EAAmBA,oBAACP,GACpBF,EAAWU,IAAIR,IAEZ,MAEXZ,EAAQM,UAAUe,mBAAqB,WACnC,IAAIX,EAAaP,KAAKM,MAAMC,WACvBG,EAAcA,eAACH,IAChBA,EAAWY,SAEnBtB,EAAQM,UAAUiB,OAAS,WACvB,OAAO,MAEJvB,EA/CA,CAgDTwB,EAAc,QAACC,0CACjB,SAAgChB,GAC5B,IAAIC,EAAagB,aAAWC,EAAAA,qBACxBhB,EAAmBe,aAAWE,EAAAA,yBAClC,OAAQJ,EAAc,QAACK,cAAc7B,EAAS8B,EAAAA,SAAS,GAAIrB,EAAO,CAAEC,WAAYA,EAAYC,iBAAkBA"}

package/build/node_modules/framer-motion/dist/es/motion/features/layout/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./Animate.js"),t={measureLayout:require("./Measure.js").MeasureContextProvider,layoutAnimation:e.AnimateLayoutContextProvider};exports.layoutAnimations=t;
+//# sourceMappingURL=index.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/layout/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/motion/features/layout/index.js"],"sourcesContent":["import { AnimateLayoutContextProvider } from './Animate.js';\nimport { MeasureContextProvider } from './Measure.js';\n\nvar layoutAnimations = {\n    measureLayout: MeasureContextProvider,\n    layoutAnimation: AnimateLayoutContextProvider,\n};\n\nexport { layoutAnimations };\n"],"names":["layoutAnimations","measureLayout","MeasureContextProvider","layoutAnimation","AnimateLayoutContextProvider"],"mappings":"kGAGIA,EAAmB,CACnBC,sCAAqCC,uBACrCC,gBAAiBC,EAA4BA"}

package/build/node_modules/framer-motion/dist/es/motion/features/layout/utils.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../../popmotion/dist/es/utils/mix.js");function t(e,t){return{min:t.min-e.min,max:t.max-e.min}}exports.calcRelativeOffset=function(e,i){return{x:t(e.x,i.x),y:t(e.y,i.y)}},exports.calcRelativeOffsetAxis=t,exports.checkIfParentHasChanged=function(e,t){var i=e.getLayoutId(),n=t.getLayoutId();return i!==n||void 0===n&&e!==t},exports.tweenAxis=function(t,i,n,r){t.min=e.mix(i.min,n.min,r),t.max=e.mix(i.max,n.max,r)};
+//# sourceMappingURL=utils.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/layout/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/motion/features/layout/utils.js"],"sourcesContent":["import { mix } from 'popmotion';\n\nfunction tweenAxis(target, prev, next, p) {\n    target.min = mix(prev.min, next.min, p);\n    target.max = mix(prev.max, next.max, p);\n}\nfunction calcRelativeOffsetAxis(parent, child) {\n    return {\n        min: child.min - parent.min,\n        max: child.max - parent.min,\n    };\n}\nfunction calcRelativeOffset(parent, child) {\n    return {\n        x: calcRelativeOffsetAxis(parent.x, child.x),\n        y: calcRelativeOffsetAxis(parent.y, child.y),\n    };\n}\nfunction checkIfParentHasChanged(prev, next) {\n    var prevId = prev.getLayoutId();\n    var nextId = next.getLayoutId();\n    return prevId !== nextId || (nextId === undefined && prev !== next);\n}\n\nexport { calcRelativeOffset, calcRelativeOffsetAxis, checkIfParentHasChanged, tweenAxis };\n"],"names":["calcRelativeOffsetAxis","parent","child","min","max","x","y","prev","next","prevId","getLayoutId","nextId","undefined","target","p","mix"],"mappings":"sIAMA,SAASA,EAAuBC,EAAQC,GACpC,MAAO,CACHC,IAAKD,EAAMC,IAAMF,EAAOE,IACxBC,IAAKF,EAAME,IAAMH,EAAOE,gCAGhC,SAA4BF,EAAQC,GAChC,MAAO,CACHG,EAAGL,EAAuBC,EAAOI,EAAGH,EAAMG,GAC1CC,EAAGN,EAAuBC,EAAOK,EAAGJ,EAAMI,sEAGlD,SAAiCC,EAAMC,GACnC,IAAIC,EAASF,EAAKG,cACdC,EAASH,EAAKE,cAClB,OAAOD,IAAWE,QAAsBC,IAAXD,GAAwBJ,IAASC,qBAnBlE,SAAmBK,EAAQN,EAAMC,EAAMM,GACnCD,EAAOV,IAAMY,EAAAA,IAAIR,EAAKJ,IAAKK,EAAKL,IAAKW,GACrCD,EAAOT,IAAMW,EAAAA,IAAIR,EAAKH,IAAKI,EAAKJ,IAAKU"}

package/build/node_modules/framer-motion/dist/es/motion/features/use-features.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../tslib/tslib.es6.js"),t=require("react"),r=require("./definitions.js"),n=require("../../../../../hey-listen/dist/hey-listen.es.js"),i=require("../../context/LazyContext.js");function o(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var s=o(t),a=Object.keys(r.featureDefinitions),u=a.length;exports.useFeatures=function(o,c,l){var f=[],d=t.useContext(i.LazyContext);if(!c)return null;"production"!==process.env.NODE_ENV&&l&&d.strict&&n.invariant(!1,"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.");for(var p=0;p<u;p++){var b=a[p],v=r.featureDefinitions[b],j=v.isEnabled,y=v.Component;j(o)&&y&&f.push(s.createElement(y,e.__assign({key:b},o,{visualElement:c})))}return f};
+//# sourceMappingURL=use-features.js.map

package/build/node_modules/framer-motion/dist/es/motion/features/use-features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-features.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/features/use-features.js"],"sourcesContent":["import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { featureDefinitions } from './definitions.js';\nimport { invariant } from 'hey-listen';\nimport { LazyContext } from '../../context/LazyContext.js';\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = useContext(LazyContext);\n    if (!visualElement)\n        return null;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (process.env.NODE_ENV !== \"production\" &&\n        preloadedFeatures &&\n        lazyContext.strict) {\n        invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React.createElement(Component, __assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\nexport { useFeatures };\n"],"names":["featureNames","Object","keys","featureDefinitions","numFeatures","length","props","visualElement","preloadedFeatures","features","lazyContext","useContext","LazyContext","process","env","NODE_ENV","strict","invariant","i","name_1","_a","isEnabled","Component","push","React","createElement","__assign","key"],"mappings":"yjBAOIA,EAAeC,OAAOC,KAAKC,EAAAA,oBAC3BC,EAAcJ,EAAaK,2BAI/B,SAAqBC,EAAOC,EAAeC,GACvC,IAAIC,EAAW,GACXC,EAAcC,aAAWC,EAAAA,aAC7B,IAAKL,EACD,OAAO,KAKkB,eAAzBM,QAAQC,IAAIC,UACZP,GACAE,EAAYM,QACZC,aAAU,EAAO,oJAErB,IAAK,IAAIC,EAAI,EAAGA,EAAId,EAAac,IAAK,CAClC,IAAIC,EAASnB,EAAakB,GACtBE,EAAKjB,qBAAmBgB,GAASE,EAAYD,EAAGC,UAAWC,EAAYF,EAAGE,UAM1ED,EAAUf,IAAUgB,GACpBb,EAASc,KAAKC,EAAMC,cAAcH,EAAWI,EAAQA,SAAC,CAAEC,IAAKR,GAAUb,EAAO,CAAEC,cAAeA,MAGvG,OAAOE"}

package/build/node_modules/framer-motion/dist/es/motion/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("./features/use-features.js"),r=require("../context/MotionConfigContext.js"),n=require("../context/MotionContext/index.js"),u=require("./utils/use-visual-element.js"),o=require("./utils/use-motion-ref.js"),i=require("../context/MotionContext/create.js"),s=require("./features/definitions.js"),a=require("../utils/is-browser.js");function l(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var c=l(e);exports.createMotionComponent=function(l){var f=l.preloadedFeatures,d=l.createVisualElement,j=l.useRender,m=l.useVisualState,v=l.Component;return f&&s.loadFeatures(f),e.forwardRef((function(s,l){var x=e.useContext(r.MotionConfigContext).isStatic,C=null,M=i.useCreateMotionContext(s,x),p=m(s,x);return!x&&a.isBrowser&&(M.visualElement=u.useVisualElement(v,p,s,d),C=t.useFeatures(s,M.visualElement,f)),c.createElement(c.Fragment,null,c.createElement(n.MotionContext.Provider,{value:M},j(v,s,o.useMotionRef(p,M.visualElement,l),p,x)),C)}))};
+//# sourceMappingURL=index.js.map

package/build/node_modules/framer-motion/dist/es/motion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/framer-motion/dist/es/motion/index.js"],"sourcesContent":["import * as React from 'react';\nimport { forwardRef, useContext } from 'react';\nimport { useFeatures } from './features/use-features.js';\nimport { MotionConfigContext } from '../context/MotionConfigContext.js';\nimport { MotionContext } from '../context/MotionContext/index.js';\nimport { useVisualElement } from './utils/use-visual-element.js';\nimport { useMotionRef } from './utils/use-motion-ref.js';\nimport { useCreateMotionContext } from '../context/MotionContext/create.js';\nimport { loadFeatures } from './features/definitions.js';\nimport { isBrowser } from '../utils/is-browser.js';\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n *\n * @internal\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var isStatic = useContext(MotionConfigContext).isStatic;\n        var features = null;\n        /**\n         * Create the tree context. This is memoized and will only trigger renders\n         * when the current tree variant changes in static mode.\n         */\n        var context = useCreateMotionContext(props, isStatic);\n        /**\n         *\n         */\n        var visualState = useVisualState(props, isStatic);\n        if (!isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, props, createVisualElement);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             *\n             * TODO: The intention is to move these away from a React-centric to a\n             * VisualElement-centric lifecycle scheme.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React.createElement(React.Fragment, null,\n            React.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic)),\n            features));\n    }\n    return forwardRef(MotionComponent);\n}\n\nexport { createMotionComponent };\n"],"names":["_a","preloadedFeatures","createVisualElement","useRender","useVisualState","Component","loadFeatures","forwardRef","props","externalRef","isStatic","useContext","MotionConfigContext","features","context","useCreateMotionContext","visualState","isBrowser","visualElement","useVisualElement","useFeatures","React","createElement","Fragment","MotionContext","Provider","value","useMotionRef"],"mappings":"svBAsBA,SAA+BA,GAC3B,IAAIC,EAAoBD,EAAGC,kBAAmBC,EAAsBF,EAAGE,oBAAqBC,EAAYH,EAAGG,UAAWC,EAAiBJ,EAAGI,eAAgBC,EAAYL,EAAGK,UA6CzK,OA5CAJ,GAAqBK,EAAAA,aAAaL,GA4C3BM,EAAAA,YA3CP,SAAyBC,EAAOC,GAO5B,IAAIC,EAAWC,EAAAA,WAAWC,EAAmBA,qBAAEF,SAC3CG,EAAW,KAKXC,EAAUC,EAAAA,uBAAuBP,EAAOE,GAIxCM,EAAcZ,EAAeI,EAAOE,GAsBxC,OArBKA,GAAYO,cAObH,EAAQI,cAAgBC,mBAAiBd,EAAWW,EAAaR,EAAON,GAQxEW,EAAWO,EAAWA,YAACZ,EAAOM,EAAQI,cAAejB,IAMjDoB,EAAMC,cAAcD,EAAME,SAAU,KACxCF,EAAMC,cAAcE,gBAAcC,SAAU,CAAEC,MAAOZ,GAAWX,EAAUE,EAAWG,EAAOmB,EAAYA,aAACX,EAAaF,EAAQI,cAAeT,GAAcO,EAAaN,IACxKG"}

package/build/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("../../render/dom/projection/scale-correction.js"),e=require("../../render/html/utils/transform.js");exports.isForcedMotionValue=function(o,t){var i=t.layout,s=t.layoutId;return e.isTransformProp(o)||e.isTransformOriginProp(o)||(i||void 0!==s)&&(!!r.valueScaleCorrection[o]||"opacity"===o)};
+//# sourceMappingURL=is-forced-motion-value.js.map

package/build/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-forced-motion-value.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.js"],"sourcesContent":["import { valueScaleCorrection } from '../../render/dom/projection/scale-correction.js';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.js';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!valueScaleCorrection[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n"],"names":["key","_a","layout","layoutId","isTransformProp","isTransformOriginProp","undefined","valueScaleCorrection"],"mappings":"mNAGA,SAA6BA,EAAKC,GAC9B,IAAIC,EAASD,EAAGC,OAAQC,EAAWF,EAAGE,SACtC,OAAQC,EAAAA,gBAAgBJ,IACpBK,EAAAA,sBAAsBL,KACpBE,QAAuBI,IAAbH,OACLI,EAAoBA,qBAACP,IAAgB,YAARA"}

package/build/node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.makeRenderlessComponent=function(e){return function(n){return e(n),null}};
+//# sourceMappingURL=make-renderless-component.js.map

package/build/node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-renderless-component.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.js"],"sourcesContent":["var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n"],"names":["hook","props"],"mappings":"oGAA8B,SAAUA,GAAQ,OAAO,SAAUC,GAE7D,OADAD,EAAKC,GACE"}

package/build/node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("../../utils/is-ref-object.js");exports.useMotionRef=function(u,r,n){return e.useCallback((function(e){var o;e&&(null===(o=u.mount)||void 0===o||o.call(u,e)),r&&(e?r.mount(e):r.unmount()),n&&("function"==typeof n?n(e):t.isRefObject(n)&&(n.current=e))}),[r])};
+//# sourceMappingURL=use-motion-ref.js.map

package/build/node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-motion-ref.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.js"],"sourcesContent":["import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.js';\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\nexport { useMotionRef };\n"],"names":["visualState","visualElement","externalRef","useCallback","instance","_a","mount","call","unmount","isRefObject","current"],"mappings":"0JAOA,SAAsBA,EAAaC,EAAeC,GAC9C,OAAOC,EAAAA,aAAY,SAAUC,GACzB,IAAIC,EACJD,IAA0C,QAA5BC,EAAKL,EAAYM,aAA0B,IAAPD,GAAyBA,EAAGE,KAAKP,EAAaI,IAC5FH,IACAG,EACMH,EAAcK,MAAMF,GACpBH,EAAcO,WAEpBN,IAC2B,mBAAhBA,EACPA,EAAYE,GAEPK,EAAAA,YAAYP,KACjBA,EAAYQ,QAAUN,MASlC,CAACH"}

package/build/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../tslib/tslib.es6.js"),t=require("react"),n=require("../../context/PresenceContext.js"),o=require("../../components/AnimatePresence/use-presence.js"),r=require("../../context/LayoutGroupContext.js"),s=require("../../context/MotionContext/index.js"),i=require("../../utils/use-isomorphic-effect.js"),u=require("../../context/MotionConfigContext.js"),a=require("../../context/LazyContext.js");exports.useVisualElement=function(c,l,x,d){var f=t.useContext(u.MotionConfigContext),C=t.useContext(a.LazyContext),p=s.useVisualElementContext(),v=t.useContext(n.PresenceContext),y=function(e){var n=e.layoutId,o=t.useContext(r.LayoutGroupContext);return o&&void 0!==n?o+"-"+n:n}(x),_=t.useRef(void 0);d||(d=C.renderer),!_.current&&d&&(_.current=d(c,{visualState:l,parent:p,props:e.__assign(e.__assign({},x),{layoutId:y}),presenceId:null==v?void 0:v.id,blockInitialAnimation:!1===(null==v?void 0:v.initial)}));var m=_.current;return i.useIsomorphicLayoutEffect((function(){m&&(m.setProps(e.__assign(e.__assign(e.__assign({},f),x),{layoutId:y})),m.isPresent=o.isPresent(v),m.isPresenceRoot=!p||p.presenceId!==(null==v?void 0:v.id),m.syncRender())})),t.useEffect((function(){var e;m&&(null===(e=m.animationState)||void 0===e||e.animateChanges())})),i.useIsomorphicLayoutEffect((function(){return function(){return null==m?void 0:m.notifyUnmount()}}),[]),m};
+//# sourceMappingURL=use-visual-element.js.map

package/build/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-visual-element.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js"],"sourcesContent":["import { __assign } from 'tslib';\nimport { useContext, useRef, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { isPresent } from '../../components/AnimatePresence/use-presence.js';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.js';\nimport { useVisualElementContext } from '../../context/MotionContext/index.js';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.js';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.js';\nimport { LazyContext } from '../../context/LazyContext.js';\n\nfunction useLayoutId(_a) {\n    var layoutId = _a.layoutId;\n    var layoutGroupId = useContext(LayoutGroupContext);\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var config = useContext(MotionConfigContext);\n    var lazyContext = useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = useContext(PresenceContext);\n    var layoutId = useLayoutId(props);\n    var visualElementRef = useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: __assign(__assign({}, props), { layoutId: layoutId }),\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        if (!visualElement)\n            return;\n        visualElement.setProps(__assign(__assign(__assign({}, config), props), { layoutId: layoutId }));\n        visualElement.isPresent = isPresent(presenceContext);\n        visualElement.isPresenceRoot =\n            !parent || parent.presenceId !== (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id);\n        /**\n         * Fire a render to ensure the latest state is reflected on-screen.\n         */\n        visualElement.syncRender();\n    });\n    useEffect(function () {\n        var _a;\n        if (!visualElement)\n            return;\n        /**\n         * In a future refactor we can replace the features-as-components and\n         * have this loop through them all firing \"effect\" listeners\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nexport { useVisualElement };\n"],"names":["Component","visualState","props","createVisualElement","config","useContext","MotionConfigContext","lazyContext","LazyContext","parent","useVisualElementContext","presenceContext","PresenceContext","layoutId","_a","layoutGroupId","LayoutGroupContext","undefined","useLayoutId","visualElementRef","useRef","renderer","current","__assign","presenceId","id","blockInitialAnimation","initial","visualElement","useIsomorphicLayoutEffect","setProps","isPresent","isPresenceRoot","syncRender","useEffect","animationState","animateChanges","notifyUnmount"],"mappings":"ggBAiBA,SAA0BA,EAAWC,EAAaC,EAAOC,GACrD,IAAIC,EAASC,aAAWC,EAAAA,qBACpBC,EAAcF,aAAWG,EAAAA,aACzBC,EAASC,EAAAA,0BACTC,EAAkBN,aAAWO,EAAAA,iBAC7BC,EAZR,SAAqBC,GACjB,IAAID,EAAWC,EAAGD,SACdE,EAAgBV,aAAWW,EAAAA,oBAC/B,OAAOD,QAA8BE,IAAbJ,EAClBE,EAAgB,IAAMF,EACtBA,EAOSK,CAAYhB,GACvBiB,EAAmBC,cAAOH,GAIzBd,IACDA,EAAsBI,EAAYc,WACjCF,EAAiBG,SAAWnB,IAC7BgB,EAAiBG,QAAUnB,EAAoBH,EAAW,CACtDC,YAAaA,EACbQ,OAAQA,EACRP,MAAOqB,EAAAA,SAASA,EAAAA,SAAS,GAAIrB,GAAQ,CAAEW,SAAUA,IACjDW,WAAYb,MAAAA,OAAyD,EAASA,EAAgBc,GAC9FC,uBAAuH,KAA/Ff,MAAAA,OAAyD,EAASA,EAAgBgB,YAGlH,IAAIC,EAAgBT,EAAiBG,QAwBrC,OAvBAO,EAAAA,2BAA0B,WACjBD,IAELA,EAAcE,SAASP,EAAAA,SAASA,EAAQA,SAACA,EAAQA,SAAC,GAAInB,GAASF,GAAQ,CAAEW,SAAUA,KACnFe,EAAcG,UAAYA,YAAUpB,GACpCiB,EAAcI,gBACTvB,GAAUA,EAAOe,cAAgBb,MAAAA,OAAyD,EAASA,EAAgBc,IAIxHG,EAAcK,iBAElBC,EAAAA,WAAU,WACN,IAAIpB,EACCc,IAMmC,QAAvCd,EAAKc,EAAcO,sBAAmC,IAAPrB,GAAyBA,EAAGsB,qBAEhFP,EAAyBA,2BAAC,WAAc,OAAO,WAAc,OAAOD,MAAAA,OAAqD,EAASA,EAAcS,mBAAuB,IAChKT"}

package/build/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../../../tslib/tslib.es6.js"),t=require("react"),n=require("../../animation/utils/is-animation-controls.js"),r=require("../../context/PresenceContext.js"),i=require("../../render/utils/variants.js"),o=require("../../utils/use-constant.js"),a=require("../../value/utils/resolve-motion-value.js"),s=require("../../context/MotionContext/index.js");function u(e,t,n,r){var i=e.scrapeMotionValuesFromProps,o=e.createRenderState,a=e.onMount,s={latestValues:l(t,n,r,i),renderState:o()};return a&&(s.mount=function(e){return a(t,e,s)}),s}function l(t,r,o,s){var u={},l=!1===(null==o?void 0:o.initial),c=s(t);for(var v in c)u[v]=a.resolveMotionValue(c[v]);var f=t.initial,x=t.animate,d=i.checkIfControllingVariants(t),m=i.checkIfVariantNode(t);r&&m&&!d&&!1!==t.inherit&&(null!=f||(f=r.initial),null!=x||(x=r.animate));var C=l||!1===f?x:f;C&&"boolean"!=typeof C&&!n.isAnimationControls(C)&&(Array.isArray(C)?C:[C]).forEach((function(n){var r=i.resolveVariantFromProps(t,n);if(r){var o=r.transitionEnd;r.transition;var a=e.__rest(r,["transitionEnd","transition"]);for(var s in a)u[s]=a[s];for(var s in o)u[s]=o[s]}}));return u}exports.makeUseVisualState=function(e){return function(n,i){var a=t.useContext(s.MotionContext),l=t.useContext(r.PresenceContext);return i?u(e,n,a,l):o.useConstant((function(){return u(e,n,a,l)}))}};
+//# sourceMappingURL=use-visual-state.js.map

package/build/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-visual-state.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js"],"sourcesContent":["import { __rest } from 'tslib';\nimport { useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.js';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { checkIfControllingVariants, checkIfVariantNode, resolveVariantFromProps } from '../../render/utils/variants.js';\nimport { useConstant } from '../../utils/use-constant.js';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.js';\nimport { MotionContext } from '../../context/MotionContext/index.js';\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) { return function (props, isStatic) {\n    var context = useContext(MotionContext);\n    var presenceContext = useContext(PresenceContext);\n    return isStatic\n        ? makeState(config, props, context, presenceContext)\n        : useConstant(function () { return makeState(config, props, context, presenceContext); });\n}; };\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var variantToSet = blockInitialAnimation || initial === false ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = __rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target)\n                values[key] = target[key];\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\n"],"names":["makeState","_a","props","context","presenceContext","scrapeMotionValuesFromProps","createRenderState","onMount","state","latestValues","makeLatestValues","renderState","mount","instance","scrapeMotionValues","values","blockInitialAnimation","initial","motionValues","key","resolveMotionValue","animate","isControllingVariants","checkIfControllingVariants","isVariantNode","checkIfVariantNode","inherit","variantToSet","isAnimationControls","Array","isArray","forEach","definition","resolved","resolveVariantFromProps","transitionEnd","transition","target","__rest","config","isStatic","useContext","MotionContext","PresenceContext","useConstant"],"mappings":"kbASA,SAASA,EAAUC,EAAIC,EAAOC,EAASC,GACnC,IAAIC,EAA8BJ,EAAGI,4BAA6BC,EAAoBL,EAAGK,kBAAmBC,EAAUN,EAAGM,QACrHC,EAAQ,CACRC,aAAcC,EAAiBR,EAAOC,EAASC,EAAiBC,GAChEM,YAAaL,KAKjB,OAHIC,IACAC,EAAMI,MAAQ,SAAUC,GAAY,OAAON,EAAQL,EAAOW,EAAUL,KAEjEA,EASX,SAASE,EAAiBR,EAAOC,EAASC,EAAiBU,GACvD,IAAIC,EAAS,GACTC,GAAwH,KAA/FZ,MAAAA,OAAyD,EAASA,EAAgBa,SAC3GC,EAAeJ,EAAmBZ,GACtC,IAAK,IAAIiB,KAAOD,EACZH,EAAOI,GAAOC,EAAAA,mBAAmBF,EAAaC,IAElD,IAAIF,EAAUf,EAAMe,QAASI,EAAUnB,EAAMmB,QACzCC,EAAwBC,6BAA2BrB,GACnDsB,EAAgBC,qBAAmBvB,GACnCC,GACAqB,IACCF,IACiB,IAAlBpB,EAAMwB,UACNT,MAAAA,IAAoDA,EAAUd,EAAQc,SACtEI,MAAAA,IAAoDA,EAAUlB,EAAQkB,UAE1E,IAAIM,EAAeX,IAAqC,IAAZC,EAAoBI,EAAUJ,EACtEU,GACwB,kBAAjBA,IACNC,EAAAA,oBAAoBD,KACVE,MAAMC,QAAQH,GAAgBA,EAAe,CAACA,IACpDI,SAAQ,SAAUC,GACnB,IAAIC,EAAWC,EAAAA,wBAAwBhC,EAAO8B,GAC9C,GAAKC,EAAL,CAEA,IAAIE,EAAgBF,EAASE,cAAeF,EAASG,WAAY,IAAIC,EAASC,EAAMA,OAACL,EAAU,CAAC,gBAAiB,eACjH,IAAK,IAAId,KAAOkB,EACZtB,EAAOI,GAAOkB,EAAOlB,GACzB,IAAK,IAAIA,KAAOgB,EACZpB,EAAOI,GAAOgB,EAAchB,OAGxC,OAAOJ,6BAxCc,SAAUwB,GAAU,OAAO,SAAUrC,EAAOsC,GACjE,IAAIrC,EAAUsC,aAAWC,EAAAA,eACrBtC,EAAkBqC,aAAWE,EAAAA,iBACjC,OAAOH,EACDxC,EAAUuC,EAAQrC,EAAOC,EAASC,GAClCwC,eAAY,WAAc,OAAO5C,EAAUuC,EAAQrC,EAAOC,EAASC"}

package/build/node_modules/framer-motion/dist/es/motion/utils/valid-prop.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var a=new Set(["initial","animate","exit","style","variants","transition","transformTemplate","transformValues","custom","inherit","layout","layoutId","_layoutResetTransform","onLayoutAnimationComplete","onViewportBoxUpdate","onLayoutMeasure","onBeforeLayoutMeasure","onAnimationStart","onAnimationComplete","onUpdate","onDragStart","onDrag","onDragEnd","onMeasureDragConstraints","onDirectionLock","onDragTransitionEnd","drag","dragControls","dragListener","dragConstraints","dragDirectionLock","_dragX","_dragY","dragElastic","dragMomentum","dragPropagation","dragTransition","whileDrag","onPan","onPanStart","onPanEnd","onPanSessionStart","onTap","onTapStart","onTapCancel","onHoverStart","onHoverEnd","whileFocus","whileTap","whileHover"]);exports.isValidMotionProp=function(n){return a.has(n)};
+//# sourceMappingURL=valid-prop.js.map

package/build/node_modules/framer-motion/dist/es/motion/utils/valid-prop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valid-prop.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/motion/utils/valid-prop.js"],"sourcesContent":["/**\n * A list of all valid MotionProps.\n *\n * @internalremarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"_layoutResetTransform\",\n    \"onLayoutAnimationComplete\",\n    \"onViewportBoxUpdate\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nexport { isValidMotionProp };\n"],"names":["validMotionProps","Set","key","has"],"mappings":"oEAMA,IAAIA,EAAmB,IAAIC,IAAI,CAC3B,UACA,UACA,OACA,QACA,WACA,aACA,oBACA,kBACA,SACA,UACA,SACA,WACA,wBACA,4BACA,sBACA,kBACA,wBACA,mBACA,sBACA,WACA,cACA,SACA,YACA,2BACA,kBACA,sBACA,OACA,eACA,eACA,kBACA,oBACA,SACA,SACA,cACA,eACA,kBACA,iBACA,YACA,QACA,aACA,WACA,oBACA,QACA,aACA,cACA,eACA,aACA,aACA,WACA,yCAUJ,SAA2BC,GACvB,OAAOF,EAAiBG,IAAID"}

package/build/node_modules/framer-motion/dist/es/render/dom/create-visual-element.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../html/visual-element.js"),r=require("../svg/visual-element.js"),t=require("./utils/is-svg-component.js");exports.createDomVisualElement=function(l,s){return t.isSVGComponent(l)?r.svgVisualElement(s,{enableHardwareAcceleration:!1}):e.htmlVisualElement(s,{enableHardwareAcceleration:!0})};
+//# sourceMappingURL=create-visual-element.js.map

package/build/node_modules/framer-motion/dist/es/render/dom/create-visual-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-visual-element.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/render/dom/create-visual-element.js"],"sourcesContent":["import { htmlVisualElement } from '../html/visual-element.js';\nimport { svgVisualElement } from '../svg/visual-element.js';\nimport { isSVGComponent } from './utils/is-svg-component.js';\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"],"names":["Component","options","isSVGComponent","svgVisualElement","enableHardwareAcceleration","htmlVisualElement"],"mappings":"6NAI6B,SAAUA,EAAWC,GAC9C,OAAOC,EAAAA,eAAeF,GAChBG,EAAAA,iBAAiBF,EAAS,CAAEG,4BAA4B,IACxDC,EAAAA,kBAAkBJ,EAAS,CAAEG,4BAA4B"}

package/build/node_modules/framer-motion/dist/es/render/dom/motion-proxy.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../motion/index.js");exports.createMotionProxy=function(t){function r(r,n){return void 0===n&&(n={}),e.createMotionComponent(t(r,n))}var n=new Map;return new Proxy(r,{get:function(e,t){return n.has(t)||n.set(t,r(t)),n.get(t)}})};
+//# sourceMappingURL=motion-proxy.js.map