{"version":3,"sources":["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","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/features-max.js"],"names":["isProjecting","visualElement","projection","isEnabled","shouldResetTransform","collectProjectingAncestors","ancestors","parent","push","collectProjectingChildren","children","addChild","child","forEach","sort","updateLayoutMeasurement","layoutState","getLayoutState","notifyBeforeLayoutMeasure","layout","isHydrated","measureViewportBox","layoutCorrected","notifyLayoutMeasure","prevViewportBox","update","rebaseProjectionTarget","snapshotViewportBox","defaultHandler","layoutReady","notifyLayoutReady","createBatcher","queue","Set","add","flush","_a","_b","read","write","order","Array","from","element","resetTransform","restoreTransform","isPresent","presence","Present","preRender","render","postRender","assignProjectionToSnapshot","clear","target","SharedLayoutContext","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate","unresolvedJobs","pushJob","stack","job","pointer","batchLayout","callback","delete","flushLayout","size","reads","writes","setRead","setWrite","numStacks","length","i","executeJob","PanSession","event","handlers","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance","offset","x","y","point","timestamp","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","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","isDragging","currentDirection","constraints","props","hasMutatedConstraints","cursorProgress","originPoint","openGlobalLock","panSession","enableLayoutProjection","set","start","originEvent","_c","snapToCursor","stopMotion","initialPoint","cancelLayout","call","tree","hasManuallySetCursorOrigin","isLayoutDrag","lockProjectionTarget","Boolean","getAxisMotionValue","isExternalDrag","scheduleUpdateLayoutProjection","axisValue","get","resolveDragConstraints","_d","drag","dragPropagation","onDragStart","animationState","setActive","Drag","_e","dragDirectionLock","lockThreshold","direction","abs","getCurrentDirection","onDirectionLock","updateAxis","onDrag","stop","dragConstraints","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","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","Component","layoutAnimations","measureLayout","createElement","layoutAnimation","domMax"],"mappings":"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","file":"15-e49044995bf7db6872d2.js","sourcesContent":["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","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 { 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"],"sourceRoot":""}