{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/context/SharedLayoutContext.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/batch-layout.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/utils/batcher.js","webpack:///./node_modules/framer-motion/dist/es/gestures/PanSession.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/features-max.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/render/dom/projection/utils.js"],"names":["SharedLayoutContext","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate","unresolvedJobs","Set","pushJob","stack","job","pointer","push","batchLayout","callback","add","delete","flushLayout","size","reads","writes","setRead","setWrite","forEach","clear","numStacks","length","i","executeJob","defaultHandler","layoutReady","child","notifyLayoutReady","createBatcher","queue","flush","_a","_b","parent","read","write","order","Array","from","sort","ancestors","element","resetTransform","restoreTransform","isPresent","presence","Present","preRender","render","postRender","assignProjectionToSnapshot","prevViewportBox","projection","target","PanSession","event","handlers","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","x","y","point","timestamp","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","update","end","onEnd","onSessionEnd","panInfo","touches","initialInfo","onSessionStart","removeListeners","window","prototype","updateHandlers","subtractPoint","a","b","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","timestampedPoint","lastPoint","time","currentVelocity","Infinity","drag","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","visualElement","hasPanEvents","panSession","MotionConfigContext","current","props","groupDragControls","dragControls","VisualElementDragControls","setProps","subscribe","mount","pixelsToPercent","pixels","axis","max","min","borderCorrectionDefinition","process","latest","_layoutState","test","parseFloat","defaultScaleCorrectors","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","treeScale","original","containsCSSVariables","includes","cssVariables","replace","match","shadow","complex","parse","template","createTransformer","xScale","scale","yScale","averageScale","mix","output","i_1","cssVariable","_super","Animate","apply","arguments","frameTarget","currentAnimationTarget","isAnimating","stopAxisAnimation","undefined","isAnimatingTree","animate","origin","originBox","targetBox","visibilityAction","shouldStackAnimate","onComplete","prevParent","config","layout","safeToRemove","isRelative","projectionParent","getProjectionParent","prevParentViewportBox","parentLayout","getLayoutState","isProvidedCorrectDataForRelativeSharedLayout","boxHasMoved","hasMoved","animations","targetLength","isTargetLocked","animateAxis","call","setProjectionTargetAxis","setVisibility","Show","syncRender","Promise","all","then","notifyLayoutAnimationComplete","componentDidMount","animateMotionValue","enableLayoutProjection","unsubLayoutReady","onLayoutUpdate","layoutSafeToRemove","componentWillUnmount","_c","_d","transition","axisIsEqual","layoutProgress","getProjectionAnimationProgress","clearListeners","set","frame","p","get","unsubscribeProgress","onChange","stop","layoutTransition","getDefaultTransition","defaultLayoutTransition","isZeroBox","zeroAxis","duration","ease","Measure","syncLayout","framerSyncLayout","register","onUnmount","remove","getSnapshotBeforeUpdate","syncUpdate","componentDidUpdate","Component","layoutAnimations","measureLayout","createElement","layoutAnimation","domMax","applyConstraints","elastic","Math","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","lastPointerEvent","elementDragControls","WeakMap","isDragging","currentDirection","constraints","hasMutatedConstraints","cursorProgress","originPoint","openGlobalLock","start","originEvent","snapToCursor","stopMotion","initialPoint","cancelLayout","children","tree","hasManuallySetCursorOrigin","isLayoutDrag","lockProjectionTarget","Boolean","getAxisMotionValue","isExternalDrag","rebaseProjectionTarget","measureViewportBox","scheduleUpdateLayoutProjection","axisValue","resolveDragConstraints","dragPropagation","onDragStart","animationState","setActive","Drag","_e","dragDirectionLock","lockThreshold","direction","abs","getCurrentDirection","onDirectionLock","updateAxis","onDrag","dragConstraints","layoutCorrected","resolveRefConstraints","layoutBox","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","measuredConstraints","calcViewportConstraints","userConstraints","cancelDrag","unlockProjectionTarget","animateDragEnd","onDragEnd","shouldDrag","box","length_1","center","updateAxisMotionValue","updateVisualElementAxis","nextValue","axisLayout","axisLength","axisProgress","progress","calcConstrainedMinPoint","_f","_g","dragMomentum","remainingProps","layoutId","dragKey","toUpperCase","getValue","_dragX","_dragY","dragTransition","getLatestValues","convertToRelativeProjection","Object","keys","relativeConstraints_1","targetFinal","isNaN","momentumAnimations","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","startLayoutAnimation","onDragTransitionEnd","stopLayoutAnimation","currentValue","scalePoint","boxProgress","updateConstraints","calcPositionFromProgress","setTimeout","onReady","getInstance","stopPointerListener","dragListener","stopResizeListener","stopLayoutUpdateListener","prevDragCursor","isProjecting","isEnabled","shouldResetTransform","collectProjectingAncestors","collectProjectingChildren","addChild","updateLayoutMeasurement","layoutState","notifyBeforeLayoutMeasure","isHydrated","notifyLayoutMeasure","snapshotViewportBox"],"mappings":"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","file":"19-58ff0f12b7db823f9f41.js","sourcesContent":["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","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 { __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 { __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 { 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 { drag } from '../../motion/features/drag.js';\nimport { layoutAnimations } from '../../motion/features/layout/index.js';\nimport { domAnimation } from './features-animation.js';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign({}, domAnimation), drag), layoutAnimations);\n\nexport { domMax };\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 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"],"sourceRoot":""}