{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/batch-layout.js","webpack:///./node_modules/framer-motion/dist/es/gestures/PanSession.js","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/convert-to-relative.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/drag.js","webpack:///./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.js","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/use-drag.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/default-scale-correctors.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/layout/Animate.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/layout/Measure.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/layout/index.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/utils.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/utils/batcher.js","webpack:///./node_modules/framer-motion/dist/es/context/SharedLayoutContext.js"],"names":["unresolvedJobs","Set","pushJob","stack","job","pointer","push","batchLayout","callback","add","delete","flushLayout","size","reads","writes","setRead","setWrite","forEach","clear","numStacks","length","i","executeJob","PanSession","event","handlers","_a","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance","offset","x","y","point","timestamp","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","update","end","onEnd","onSessionEnd","panInfo","touches","initialInfo","onSessionStart","removeListeners","pipe","window","prototype","updateHandlers","subtractPoint","a","b","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","timestampedPoint","lastPoint","time","currentVelocity","Infinity","applyConstraints","elastic","min","max","undefined","mix","Math","calcRelativeAxisConstraints","axis","calcViewportAxisConstraints","layoutAxis","constraintsAxis","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","lastPointerEvent","elementDragControls","WeakMap","VisualElementDragControls","visualElement","isDragging","currentDirection","constraints","props","hasMutatedConstraints","cursorProgress","originPoint","openGlobalLock","panSession","enableLayoutProjection","set","start","originEvent","_b","_c","snapToCursor","stopMotion","initialPoint","cancelLayout","call","read","write","ancestors","children","tree","hasManuallySetCursorOrigin","isLayoutDrag","lockProjectionTarget","element","resetTransform","restoreTransform","Boolean","getAxisMotionValue","isExternalDrag","rebaseProjectionTarget","measureViewportBox","scheduleUpdateLayoutProjection","projection","target","axisValue","get","preRender","render","postRender","resolveDragConstraints","_d","drag","dragPropagation","onDragStart","animationState","setActive","Drag","_e","dragDirectionLock","lockThreshold","direction","abs","getCurrentDirection","onDirectionLock","updateAxis","onDrag","stop","dragConstraints","layout","getLayoutState","layoutCorrected","resolveRefConstraints","layoutBox","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","current","constraintsBox","measuredConstraints","calcViewportConstraints","userConstraints","cancelDrag","unlockProjectionTarget","animateDragEnd","onDragEnd","shouldDrag","box","length_1","center","includes","updateAxisMotionValue","updateVisualElementAxis","nextValue","axisLayout","axisLength","axisProgress","progress","calcConstrainedMinPoint","setProjectionTargetAxis","setProps","_f","_g","dragMomentum","remainingProps","layoutId","dragKey","toUpperCase","getValue","_dragX","_dragY","dragTransition","isRelative","projectionParent","getProjectionParent","getLatestValues","convertToRelativeProjection","Object","keys","relativeConstraints_1","targetFinal","isNaN","momentumAnimations","transition","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","startLayoutAnimation","Promise","all","then","onDragTransitionEnd","stopLayoutAnimation","currentValue","scalePoint","boxProgress","updateConstraints","calcPositionFromProgress","setTimeout","onReady","mount","getInstance","stopPointerListener","dragListener","stopResizeListener","stopLayoutUpdateListener","onLayoutUpdate","prevDragCursor","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","MotionConfigContext","groupDragControls","dragControls","subscribe","pixelsToPercent","pixels","borderCorrectionDefinition","process","latest","_layoutState","test","parseFloat","defaultScaleCorrectors","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","treeScale","original","containsCSSVariables","cssVariables","replace","match","shadow","complex","parse","template","createTransformer","xScale","scale","yScale","averageScale","output","i_1","cssVariable","_super","Animate","apply","arguments","frameTarget","currentAnimationTarget","isAnimating","stopAxisAnimation","isAnimatingTree","animate","origin","originBox","targetBox","visibilityAction","shouldStackAnimate","onComplete","prevParent","config","safeToRemove","prevParentViewportBox","prevViewportBox","parentLayout","isProvidedCorrectDataForRelativeSharedLayout","boxHasMoved","hasMoved","animations","targetLength","isTargetLocked","animateAxis","setVisibility","Show","syncRender","notifyLayoutAnimationComplete","componentDidMount","animateMotionValue","unsubLayoutReady","layoutSafeToRemove","componentWillUnmount","axisIsEqual","layoutProgress","getProjectionAnimationProgress","clearListeners","frame","p","unsubscribeProgress","onChange","layoutTransition","getDefaultTransition","defaultLayoutTransition","isZeroBox","zeroAxis","duration","ease","Measure","syncLayout","framerSyncLayout","register","onUnmount","remove","getSnapshotBeforeUpdate","syncUpdate","componentDidUpdate","flush","Component","layoutAnimations","measureLayout","SharedLayoutContext","createElement","layoutAnimation","featureBundle","isProjecting","isEnabled","shouldResetTransform","collectProjectingAncestors","parent","collectProjectingChildren","addChild","child","sort","updateLayoutMeasurement","layoutState","notifyBeforeLayoutMeasure","isHydrated","notifyLayoutMeasure","snapshotViewportBox","defaultHandler","layoutReady","notifyLayoutReady","createBatcher","queue","order","Array","from","isPresent","presence","Present","assignProjectionToSnapshot","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate"],"mappings":"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","file":"2-3a0b70e2347772b0c12f.js","sourcesContent":["var unresolvedJobs = new Set();\nfunction pushJob(stack, job, pointer) {\n    if (!stack[pointer])\n        stack[pointer] = [];\n    stack[pointer].push(job);\n}\nfunction batchLayout(callback) {\n    unresolvedJobs.add(callback);\n    return function () { return unresolvedJobs.delete(callback); };\n}\nfunction flushLayout() {\n    if (!unresolvedJobs.size)\n        return;\n    var pointer = 0;\n    var reads = [[]];\n    var writes = [];\n    var setRead = function (job) { return pushJob(reads, job, pointer); };\n    var setWrite = function (job) {\n        pushJob(writes, job, pointer);\n        pointer++;\n    };\n    /**\n     * Resolve jobs into their array stacks\n     */\n    unresolvedJobs.forEach(function (callback) {\n        callback(setRead, setWrite);\n        pointer = 0;\n    });\n    unresolvedJobs.clear();\n    /**\n     * Execute jobs\n     */\n    var numStacks = writes.length;\n    for (var i = 0; i <= numStacks; i++) {\n        reads[i] && reads[i].forEach(executeJob);\n        writes[i] && writes[i].forEach(executeJob);\n    }\n}\nvar executeJob = function (job) { return job(); };\n\nexport { batchLayout, flushLayout };\n","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.js';\nimport { extractEventInfo } from '../events/event-info.js';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.js';\nimport { addPointerEvent } from '../events/use-pointer-event.js';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\n","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","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","import { calcRelativeOffset } from '../../../motion/features/layout/utils.js';\nimport { eachAxis } from '../../../utils/each-axis.js';\nimport { removeBoxTransforms } from '../../../utils/geometry/delta-apply.js';\n\n/**\n * Returns a boolean stating whether or not we converted the projection\n * to relative projection.\n */\nfunction convertToRelativeProjection(visualElement, isLayoutDrag) {\n    if (isLayoutDrag === void 0) { isLayoutDrag = true; }\n    var projectionParent = visualElement.getProjectionParent();\n    if (!projectionParent)\n        return false;\n    var offset;\n    if (isLayoutDrag) {\n        offset = calcRelativeOffset(projectionParent.projection.target, visualElement.projection.target);\n        removeBoxTransforms(offset, projectionParent.getLatestValues());\n    }\n    else {\n        offset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n    }\n    eachAxis(function (axis) {\n        return visualElement.setProjectionTargetAxis(axis, offset[axis].min, offset[axis].max, true);\n    });\n    return true;\n}\n\nexport { convertToRelativeProjection };\n","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","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","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","import { __assign } from 'tslib';\nimport { complex, px } from 'style-value-types';\nimport { mix } from 'popmotion';\nimport { cssVariableRegex } from '../utils/css-variables-conversion.js';\n\nfunction pixelsToPercent(pixels, axis) {\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nfunction correctBorderRadius(latest, _layoutState, _a) {\n    var target = _a.target;\n    /**\n     * If latest is a string, if it's a percentage we can return immediately as it's\n     * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n     */\n    if (typeof latest === \"string\") {\n        if (px.test(latest)) {\n            latest = parseFloat(latest);\n        }\n        else {\n            return latest;\n        }\n    }\n    /**\n     * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n     * pixel value as a percentage of each axis\n     */\n    var x = pixelsToPercent(latest, target.x);\n    var y = pixelsToPercent(latest, target.y);\n    return x + \"% \" + y + \"%\";\n}\nvar varToken = \"_$css\";\nfunction correctBoxShadow(latest, _a) {\n    var delta = _a.delta, treeScale = _a.treeScale;\n    var original = latest;\n    /**\n     * We need to first strip and store CSS variables from the string.\n     */\n    var containsCSSVariables = latest.includes(\"var(\");\n    var cssVariables = [];\n    if (containsCSSVariables) {\n        latest = latest.replace(cssVariableRegex, function (match) {\n            cssVariables.push(match);\n            return varToken;\n        });\n    }\n    var shadow = complex.parse(latest);\n    // TODO: Doesn't support multiple shadows\n    if (shadow.length > 5)\n        return original;\n    var template = complex.createTransformer(latest);\n    var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n    // Calculate the overall context scale\n    var xScale = delta.x.scale * treeScale.x;\n    var yScale = delta.y.scale * treeScale.y;\n    shadow[0 + offset] /= xScale;\n    shadow[1 + offset] /= yScale;\n    /**\n     * Ideally we'd correct x and y scales individually, but because blur and\n     * spread apply to both we have to take a scale average and apply that instead.\n     * We could potentially improve the outcome of this by incorporating the ratio between\n     * the two scales.\n     */\n    var averageScale = mix(xScale, yScale, 0.5);\n    // Blur\n    if (typeof shadow[2 + offset] === \"number\")\n        shadow[2 + offset] /= averageScale;\n    // Spread\n    if (typeof shadow[3 + offset] === \"number\")\n        shadow[3 + offset] /= averageScale;\n    var output = template(shadow);\n    if (containsCSSVariables) {\n        var i_1 = 0;\n        output = output.replace(varToken, function () {\n            var cssVariable = cssVariables[i_1];\n            i_1++;\n            return cssVariable;\n        });\n    }\n    return output;\n}\nvar borderCorrectionDefinition = {\n    process: correctBorderRadius,\n};\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, borderCorrectionDefinition), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: borderCorrectionDefinition,\n    borderTopRightRadius: borderCorrectionDefinition,\n    borderBottomLeftRadius: borderCorrectionDefinition,\n    borderBottomRightRadius: borderCorrectionDefinition,\n    boxShadow: {\n        process: correctBoxShadow,\n    },\n};\n\nexport { correctBorderRadius, correctBoxShadow, defaultScaleCorrectors, pixelsToPercent };\n","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","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","import { AnimateLayoutContextProvider } from './Animate.js';\nimport { MeasureContextProvider } from './Measure.js';\n\nvar layoutAnimations = {\n    measureLayout: MeasureContextProvider,\n    layoutAnimation: AnimateLayoutContextProvider,\n};\n\nexport { layoutAnimations };\n","import { __assign } from 'tslib';\nimport { createMotionComponent } from '../../motion/index.js';\nimport { createMotionProxy } from './motion-proxy.js';\nimport { createDomMotionConfig } from './utils/create-config.js';\nimport { gestureAnimations } from '../../motion/features/gestures.js';\nimport { animations } from '../../motion/features/animations.js';\nimport { drag } from '../../motion/features/drag.js';\nimport { layoutAnimations } from '../../motion/features/layout/index.js';\nimport { createDomVisualElement } from './create-visual-element.js';\n\nvar featureBundle = __assign(__assign(__assign(__assign({}, animations), gestureAnimations), drag), layoutAnimations);\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nvar motion = /*@__PURE__*/ createMotionProxy(function (Component, config) {\n    return createDomMotionConfig(Component, config, featureBundle, createDomVisualElement);\n});\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, featureBundle, createDomVisualElement));\n}\n\nexport { createDomMotionComponent, motion };\n","import sync from 'framesync';\nimport { copyAxisBox } from '../../../utils/geometry/index.js';\nimport { compareByDepth } from '../../utils/compare-by-depth.js';\n\nfunction isProjecting(visualElement) {\n    var isEnabled = visualElement.projection.isEnabled;\n    return isEnabled || visualElement.shouldResetTransform();\n}\nfunction collectProjectingAncestors(visualElement, ancestors) {\n    if (ancestors === void 0) { ancestors = []; }\n    var parent = visualElement.parent;\n    if (parent)\n        collectProjectingAncestors(parent, ancestors);\n    if (isProjecting(visualElement))\n        ancestors.push(visualElement);\n    return ancestors;\n}\nfunction collectProjectingChildren(visualElement) {\n    var children = [];\n    var addChild = function (child) {\n        if (isProjecting(child))\n            children.push(child);\n        child.children.forEach(addChild);\n    };\n    visualElement.children.forEach(addChild);\n    return children.sort(compareByDepth);\n}\n/**\n * Update the layoutState by measuring the DOM layout. This\n * should be called after resetting any layout-affecting transforms.\n */\nfunction updateLayoutMeasurement(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    var layoutState = visualElement.getLayoutState();\n    visualElement.notifyBeforeLayoutMeasure(layoutState.layout);\n    layoutState.isHydrated = true;\n    layoutState.layout = visualElement.measureViewportBox();\n    layoutState.layoutCorrected = copyAxisBox(layoutState.layout);\n    visualElement.notifyLayoutMeasure(layoutState.layout, visualElement.prevViewportBox || layoutState.layout);\n    sync.update(function () { return visualElement.rebaseProjectionTarget(); });\n}\n/**\n * Record the viewport box as it was before an expected mutation/re-render\n */\nfunction snapshotViewportBox(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    visualElement.prevViewportBox = visualElement.measureViewportBox(false);\n    /**\n     * Update targetBox to match the prevViewportBox. This is just to ensure\n     * that targetBox is affected by scroll in the same way as the measured box\n     */\n    visualElement.rebaseProjectionTarget(false, visualElement.prevViewportBox);\n}\n\nexport { collectProjectingAncestors, collectProjectingChildren, snapshotViewportBox, updateLayoutMeasurement };\n","import { __spreadArray, __read } from 'tslib';\nimport sync, { flushSync } from 'framesync';\nimport { collectProjectingAncestors, updateLayoutMeasurement } from '../../../render/dom/projection/utils.js';\nimport { batchLayout, flushLayout } from '../../../render/dom/utils/batch-layout.js';\nimport { compareByDepth } from '../../../render/utils/compare-by-depth.js';\nimport { Presence } from '../types.js';\n\n/**\n * Default handlers for batching VisualElements\n */\nvar defaultHandler = {\n    layoutReady: function (child) { return child.notifyLayoutReady(); },\n};\n/**\n * Create a batcher to process VisualElements\n */\nfunction createBatcher() {\n    var queue = new Set();\n    return {\n        add: function (child) { return queue.add(child); },\n        flush: function (_a) {\n            var _b = _a === void 0 ? defaultHandler : _a, layoutReady = _b.layoutReady, parent = _b.parent;\n            batchLayout(function (read, write) {\n                var order = Array.from(queue).sort(compareByDepth);\n                var ancestors = parent\n                    ? collectProjectingAncestors(parent)\n                    : [];\n                write(function () {\n                    var allElements = __spreadArray(__spreadArray([], __read(ancestors)), __read(order));\n                    allElements.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    order.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    ancestors.forEach(function (element) { return element.restoreTransform(); });\n                    order.forEach(layoutReady);\n                });\n                read(function () {\n                    /**\n                     * After all children have started animating, ensure any Entering components are set to Present.\n                     * If we add deferred animations (set up all animations and then start them in two loops) this\n                     * could be moved to the start loop. But it needs to happen after all the animations configs\n                     * are generated in AnimateSharedLayout as this relies on presence data\n                     */\n                    order.forEach(function (child) {\n                        if (child.isPresent)\n                            child.presence = Presence.Present;\n                    });\n                });\n                write(function () {\n                    /**\n                     * Starting these animations will have queued jobs on the frame loop. In some situations,\n                     * like when removing an element, these will be processed too late after the DOM is manipulated,\n                     * leaving a flash of incorrectly-projected content. By manually flushing these jobs\n                     * we ensure there's no flash.\n                     */\n                    flushSync.preRender();\n                    flushSync.render();\n                });\n                read(function () {\n                    /**\n                     * Schedule a callback at the end of the following frame to assign the latest projection\n                     * box to the prevViewportBox snapshot. Once global batching is in place this could be run\n                     * synchronously. But for now it ensures that if any nested `AnimateSharedLayout` top-level\n                     * child attempts to calculate its previous relative position against a prevViewportBox\n                     * it will be against its latest projection box instead, as the snapshot is useless beyond this\n                     * render.\n                     */\n                    sync.postRender(function () {\n                        return order.forEach(assignProjectionToSnapshot);\n                    });\n                    queue.clear();\n                });\n            });\n            // TODO: Need to find a layout-synchronous way of flushing this\n            flushLayout();\n        },\n    };\n}\nfunction assignProjectionToSnapshot(child) {\n    child.prevViewportBox = child.projection.target;\n}\n\nexport { createBatcher };\n","import { createContext } from 'react';\nimport { createBatcher } from '../components/AnimateSharedLayout/utils/batcher.js';\n\nvar SharedLayoutContext = createContext(createBatcher());\n/**\n * @internal\n */\nvar FramerTreeLayoutContext = createContext(createBatcher());\nfunction isSharedLayout(context) {\n    return !!context.forceUpdate;\n}\n\nexport { FramerTreeLayoutContext, SharedLayoutContext, isSharedLayout };\n"],"sourceRoot":""}