{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/utils.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/components/AnimateSharedLayout/utils/batcher.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","SharedLayoutContext","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate","unresolvedJobs","Set","pushJob","stack","job","pointer","batchLayout","callback","add","delete","flushLayout","size","reads","writes","setRead","setWrite","clear","numStacks","length","i","executeJob","defaultHandler","layoutReady","notifyLayoutReady","createBatcher","queue","flush","_a","_b","read","write","order","Array","from","element","resetTransform","restoreTransform","isPresent","presence","Present","preRender","render","postRender","assignProjectionToSnapshot","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","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","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":"vendors~HomepageCarousel~SearchHeroBanner~SiteHeader~TabbedSection~YourSolutionRoot-3999e79c9e94567788e5.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 { 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 { __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":""}